diff --git a/build.rs b/build.rs index 7138201..4ac1595 100644 --- a/build.rs +++ b/build.rs @@ -94,7 +94,9 @@ fn main() { } cfg.include(out.join("htslib")); - + if target_os == "windows" { + cfg.include(out.join("win32")); + } let want_static = cfg!(feature = "static") || env::var("HTS_STATIC").is_ok(); if want_static { @@ -107,12 +109,14 @@ fn main() { cfg.include(z_inc); lib_list += " -lz"; } - + let mut config_lines = vec!["/* Default config.h generated by build.rs */"]; // We build a config.h ourselves, rather than rely on Makefile or ./configure - let mut config_lines = vec![ - "/* Default config.h generated by build.rs */", - "#define HAVE_DRAND48 1", - ]; + if target_os == "windows" { + config_lines.push("//#define HAVE_DRAND48 1"); + } + else { + config_lines.push("#define HAVE_DRAND48 1"); + } let use_bzip2 = env::var("CARGO_FEATURE_BZIP2").is_ok(); if use_bzip2 { @@ -226,7 +230,7 @@ fn main() { // write out version.h { - let version = std::process::Command::new(out.join("htslib").join("version.sh")) + let version = std::process::Command::new("sh").args(["-c", "htslib/version.sh"]) .output() .expect("failed to execute process"); let version_str = std::str::from_utf8(&version.stdout).unwrap().trim(); @@ -284,6 +288,11 @@ fn main() { fs::copy("osx_prebuilt_bindings.rs", out.join("bindings.rs")) .expect("couldn't copy prebuilt bindings"); println!("cargo:rerun-if-changed=osx_prebuilt_bindings.rs"); + } + else if target_os == "windows" { + fs::copy("windows_prebuilt_bindings.rs", out.join("bindings.rs")) + .expect("couldn't copy prebuilt bindings"); + println!("cargo:rerun-if-changed=windows_prebuilt_bindings.rs"); } else { fs::copy("linux_prebuilt_bindings.rs", out.join("bindings.rs")) .expect("couldn't copy prebuilt bindings"); diff --git a/win32/getopt.c b/win32/getopt.c new file mode 100644 index 0000000..9814484 --- /dev/null +++ b/win32/getopt.c @@ -0,0 +1,1261 @@ +/* Getopt for GNU. + NOTE: getopt is now part of the C library, so if you don't know what + "Keep this file name-space clean" means, talk to drepper@gnu.org + before changing it! + Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001 + Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* This tells Alpha OSF/1 not to define a getopt prototype in . + Ditto for AIX 3.2 and . */ +#ifndef _NO_PROTO +# define _NO_PROTO +#endif + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if !defined __STDC__ || !__STDC__ +/* This is a separate conditional since some stdc systems + reject `defined (const)'. */ +# ifndef const +# define const +# endif +#endif + +#include + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#define GETOPT_INTERFACE_VERSION 2 +#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 +# include +# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION +# define ELIDE_CODE +# endif +#endif + +#ifndef ELIDE_CODE + + +/* This needs to come after some library #include + to get __GNU_LIBRARY__ defined. */ +#ifdef __GNU_LIBRARY__ +/* Don't include stdlib.h for non-GNU C libraries because some of them + contain conflicting prototypes for getopt. */ +# include +# include +#endif /* GNU C library. */ + +#ifdef VMS +# include +# if HAVE_STRING_H - 0 +# include +# endif +#endif + +#ifndef _ +/* This is for other GNU distributions with internationalized messages. */ +# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC +# include +# ifndef _ +# define _(msgid) gettext (msgid) +# endif +# else +# define _(msgid) (msgid) +# endif +# if defined _LIBC && defined USE_IN_LIBIO +# include +# endif +#endif + +/* This version of `getopt' appears to the caller like standard Unix `getopt' + but it behaves differently for the user, since it allows the user + to intersperse the options with the other arguments. + + As `getopt' works, it permutes the elements of ARGV so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable POSIXLY_CORRECT disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + +#include "getopt.h" + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +/* 1003.2 says this must be 1 before any call. */ +int optind = 1; + +/* Formerly, initialization of getopt depended on optind==0, which + causes problems with re-calling getopt as programs generally don't + know that. */ + +int __getopt_initialized; + +/* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + +static char *nextchar; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int opterr = 1; + +/* Set to an option character which was unrecognized. + This must be initialized on some systems to avoid linking in the + system's own getopt implementation. */ + +int optopt = '?'; + +/* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + POSIXLY_CORRECT is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable POSIXLY_CORRECT, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `getopt' to return -1 with `optind' != ARGC. */ + +static enum +{ + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +} ordering; + +/* Value of POSIXLY_CORRECT environment variable. */ +static char *posixly_correct; + +#ifdef __GNU_LIBRARY__ +/* We want to avoid inclusion of string.h with non-GNU libraries + because there are many ways it can cause trouble. + On some systems, it contains special magic macros that don't work + in GCC. */ +# include +# define my_index strchr +#else + +/* +# if HAVE_STRING_H || WIN32 /* Pete Wilson mod 7/28/02 * / +# include +# else +# include +# endif +*/ + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +#ifndef getenv +extern char *getenv (); +#endif + +static char * +my_index (str, chr) + const char *str; + int chr; +{ + while (*str) + { + if (*str == chr) + return (char *) str; + str++; + } + return 0; +} + +/* If using GCC, we can safely declare strlen this way. + If not using GCC, it is ok not to declare it. */ +#ifdef __GNUC__ +/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. + That was relevant to code that was here before. */ +# if (!defined __STDC__ || !__STDC__) && !defined strlen +/* gcc with -traditional declares the built-in strlen to return int, + and has done so at least since version 2.4.5. -- rms. */ +extern int strlen (const char *); +# endif /* not __STDC__ */ +#endif /* __GNUC__ */ + +#endif /* not __GNU_LIBRARY__ */ + +/* Handle permutation of arguments. */ + +/* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + +static int first_nonopt; +static int last_nonopt; + +#ifdef _LIBC +/* Stored original parameters. + XXX This is no good solution. We should rather copy the args so + that we can compare them later. But we must not use malloc(3). */ +extern int __libc_argc; +extern char **__libc_argv; + +/* Bash 2.0 gives us an environment variable containing flags + indicating ARGV elements that should not be considered arguments. */ + +# ifdef USE_NONOPTION_FLAGS +/* Defined in getopt_init.c */ +extern char *__getopt_nonoption_flags; + +static int nonoption_flags_max_len; +static int nonoption_flags_len; +# endif + +# ifdef USE_NONOPTION_FLAGS +# define SWAP_FLAGS(ch1, ch2) \ + if (nonoption_flags_len > 0) \ + { \ + char __tmp = __getopt_nonoption_flags[ch1]; \ + __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ + __getopt_nonoption_flags[ch2] = __tmp; \ + } +# else +# define SWAP_FLAGS(ch1, ch2) +# endif +#else /* !_LIBC */ +# define SWAP_FLAGS(ch1, ch2) +#endif /* _LIBC */ + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +#if defined __STDC__ && __STDC__ +static void exchange (char **); +#endif + +static void +exchange (argv) + char **argv; +{ + int bottom = first_nonopt; + int middle = last_nonopt; + int top = optind; + char *tem; + + /* Exchange the shorter segment with the far end of the longer segment. + That puts the shorter segment into the right place. + It leaves the longer segment in the right place overall, + but it consists of two parts that need to be swapped next. */ + +#if defined _LIBC && defined USE_NONOPTION_FLAGS + /* First make sure the handling of the `__getopt_nonoption_flags' + string can work normally. Our top argument must be in the range + of the string. */ + if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) + { + /* We must extend the array. The user plays games with us and + presents new arguments. */ + char *new_str = malloc (top + 1); + if (new_str == NULL) + nonoption_flags_len = nonoption_flags_max_len = 0; + else + { + memset (__mempcpy (new_str, __getopt_nonoption_flags, + nonoption_flags_max_len), + '\0', top + 1 - nonoption_flags_max_len); + nonoption_flags_max_len = top + 1; + __getopt_nonoption_flags = new_str; + } + } +#endif + + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + /* Bottom segment is the short one. */ + int len = middle - bottom; + register int i; + + /* Swap it with the top part of the top segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } + else + { + /* Top segment is the short one. */ + int len = top - middle; + register int i; + + /* Swap it with the bottom part of the bottom segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + SWAP_FLAGS (bottom + i, middle + i); + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } + } + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; +} + +/* Initialize the internal data when the first call is made. */ + +#if defined __STDC__ && __STDC__ +static const char *_getopt_initialize (int, char *const *, const char *); +#endif +static const char * +_getopt_initialize (argc, argv, optstring) + int argc; + char *const *argv; + const char *optstring; +{ + /* Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + first_nonopt = last_nonopt = optind; + + nextchar = NULL; + + posixly_correct = getenv ("POSIXLY_CORRECT"); + + /* Determine how to handle the ordering of options and nonoptions. */ + + if (optstring[0] == '-') + { + ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + ordering = REQUIRE_ORDER; + ++optstring; + } + else if (posixly_correct != NULL) + ordering = REQUIRE_ORDER; + else + ordering = PERMUTE; + +#if defined _LIBC && defined USE_NONOPTION_FLAGS + if (posixly_correct == NULL + && argc == __libc_argc && argv == __libc_argv) + { + if (nonoption_flags_max_len == 0) + { + if (__getopt_nonoption_flags == NULL + || __getopt_nonoption_flags[0] == '\0') + nonoption_flags_max_len = -1; + else + { + const char *orig_str = __getopt_nonoption_flags; + int len = nonoption_flags_max_len = strlen (orig_str); + if (nonoption_flags_max_len < argc) + nonoption_flags_max_len = argc; + __getopt_nonoption_flags = + (char *) malloc (nonoption_flags_max_len); + if (__getopt_nonoption_flags == NULL) + nonoption_flags_max_len = -1; + else + memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), + '\0', nonoption_flags_max_len - len); + } + } + nonoption_flags_len = nonoption_flags_max_len; + } + else + nonoption_flags_len = 0; +#endif + + return optstring; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `getopt' finds another option character, it returns that character, + updating `optind' and `nextchar' so that the next call to `getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `getopt' returns -1. + Then `optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `optarg', otherwise `optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `--' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + if the `flag' field is zero. + + The elements of ARGV aren't really const, because we permute them. + But we pretend they're const in the prototype to be compatible + with other systems. + + LONGOPTS is a vector of `struct option' terminated by an + element containing a name which is zero. + + LONGIND returns the index in LONGOPT of the long-named option found. + It is only valid when a long-named option has been found by the most + recent call. + + If LONG_ONLY is nonzero, '-' as well as '--' can introduce + long-named options. */ + +int +_getopt_internal (argc, argv, optstring, longopts, longind, long_only) + int argc; + char *const *argv; + const char *optstring; + const struct option *longopts; + int *longind; + int long_only; +{ + int print_errors = opterr; + if (optstring[0] == ':') + print_errors = 0; + + if (argc < 1) + return -1; + + optarg = NULL; + + if (optind == 0 || !__getopt_initialized) + { + if (optind == 0) + optind = 1; /* Don't scan ARGV[0], the program name. */ + optstring = _getopt_initialize (argc, argv, optstring); + __getopt_initialized = 1; + } + + /* Test whether ARGV[optind] points to a non-option argument. + Either it does not have option syntax, or there is an environment flag + from the shell indicating it is not an option. The later information + is only used when the used in the GNU libc. */ +#if defined _LIBC && defined USE_NONOPTION_FLAGS +# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ + || (optind < nonoption_flags_len \ + && __getopt_nonoption_flags[optind] == '1')) +#else +# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') +#endif + + if (nextchar == NULL || *nextchar == '\0') + { + /* Advance to the next ARGV-element. */ + + /* Give FIRST_NONOPT and LAST_NONOPT rational values if OPTIND has been + moved back by the user (who may also have changed the arguments). */ + if (last_nonopt > optind) + last_nonopt = optind; + if (first_nonopt > optind) + first_nonopt = optind; + + if (ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (last_nonopt != optind) + first_nonopt = optind; + + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (optind < argc && NONOPTION_P) + optind++; + last_nonopt = optind; + } + + /* The special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (optind != argc && !strcmp (argv[optind], "--")) + { + optind++; + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; + + optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return -1; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if (NONOPTION_P) + { + if (ordering == REQUIRE_ORDER) + return -1; + optarg = argv[optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Skip the initial punctuation. */ + + nextchar = (argv[optind] + 1 + + (longopts != NULL && argv[optind][1] == '-')); + } + + /* Decode the current option-ARGV-element. */ + + /* Check whether the ARGV-element is a long option. + + If long_only and the ARGV-element has the form "-f", where f is + a valid short option, don't consider it an abbreviated form of + a long option that starts with f. Otherwise there would be no + way to give the -f short option. + + On the other hand, if there's a long option "fubar" and + the ARGV-element is "-fu", do consider that an abbreviation of + the long option, just like "--fu", and not "-f" with arg "u". + + This distinction seems to be the most useful approach. */ + + if (longopts != NULL + && (argv[optind][1] == '-' + || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) + { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = -1; + int option_index; + + for (nameend = nextchar; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) + == (unsigned int) strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else if (long_only + || pfound->has_arg != p->has_arg + || pfound->flag != p->flag + || pfound->val != p->val) + /* Second or later nonexact match found. */ + ambig = 1; + } + + if (ambig && !exact) + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[optind]); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[optind]); +#endif + } + nextchar += strlen (nextchar); + optind++; + optopt = 0; + return '?'; + } + + if (pfound != NULL) + { + option_index = indfound; + optind++; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; +#endif + + if (argv[optind - 1][1] == '-') + { + /* --option */ +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("\ +%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); +#else + fprintf (stderr, _("\ +%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); +#endif + } + else + { + /* +option or -option */ +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("\ +%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[optind - 1][0], + pfound->name); +#else + fprintf (stderr, _("\ +%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[optind - 1][0], pfound->name); +#endif + } + +#if defined _LIBC && defined USE_IN_LIBIO + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#endif + } + + nextchar += strlen (nextchar); + + optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); +#endif + } + nextchar += strlen (nextchar); + optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + + /* Can't find it as a long option. If this is not getopt_long_only, + or the option starts with '--' or is not a valid short + option, then it's an error. + Otherwise interpret it as a short option. */ + if (!long_only || argv[optind][1] == '-' + || my_index (optstring, *nextchar) == NULL) + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; +#endif + + if (argv[optind][1] == '-') + { + /* --option */ +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); +#else + fprintf (stderr, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); +#endif + } + else + { + /* +option or -option */ +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[optind][0], nextchar); +#else + fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[optind][0], nextchar); +#endif + } + +#if defined _LIBC && defined USE_IN_LIBIO + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#endif + } + nextchar = (char *) ""; + optind++; + optopt = 0; + return '?'; + } + } + + /* Look at and handle the next short option-character. */ + + { + char c = *nextchar++; + char *temp = my_index (optstring, c); + + /* Increment `optind' when we start to process its last character. */ + if (*nextchar == '\0') + ++optind; + + if (temp == NULL || c == ':') + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; +#endif + + if (posixly_correct) + { + /* 1003.2 specifies the format of this message. */ +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("%s: illegal option -- %c\n"), + argv[0], c); +#else + fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c); +#endif + } + else + { +#if defined _LIBC && defined USE_IN_LIBIO + __asprintf (&buf, _("%s: invalid option -- %c\n"), + argv[0], c); +#else + fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c); +#endif + } + +#if defined _LIBC && defined USE_IN_LIBIO + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#endif + } + optopt = c; + return '?'; + } + /* Convenience. Treat POSIX -W foo same as long option --foo */ + if (temp[0] == 'W' && temp[1] == ';') + { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (print_errors) + { + /* 1003.2 specifies the format of this message. */ +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, _("%s: option requires an argument -- %c\n"), + argv[0], c); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, _("%s: option requires an argument -- %c\n"), + argv[0], c); +#endif + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + return c; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + + /* optarg is now the argument, see if it's in the + table of longopts. */ + + for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } + if (ambig && !exact) + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"), + argv[0], argv[optind]); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), + argv[0], argv[optind]); +#endif + } + nextchar += strlen (nextchar); + optind++; + return '?'; + } + if (pfound != NULL) + { + option_index = indfound; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, _("\ +%s: option `-W %s' doesn't allow an argument\n"), + argv[0], pfound->name); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, _("\ +%s: option `-W %s' doesn't allow an argument\n"), + argv[0], pfound->name); +#endif + } + + nextchar += strlen (nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (print_errors) + { +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, _("\ +%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); +#endif + } + nextchar += strlen (nextchar); + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + nextchar = NULL; + return 'W'; /* Let the application handle it. */ + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != '\0') + { + optarg = nextchar; + optind++; + } + else + optarg = NULL; + nextchar = NULL; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (print_errors) + { + /* 1003.2 specifies the format of this message. */ +#if defined _LIBC && defined USE_IN_LIBIO + char *buf; + + __asprintf (&buf, + _("%s: option requires an argument -- %c\n"), + argv[0], c); + + if (_IO_fwide (stderr, 0) > 0) + __fwprintf (stderr, L"%s", buf); + else + fputs (buf, stderr); + + free (buf); +#else + fprintf (stderr, + _("%s: option requires an argument -- %c\n"), + argv[0], c); +#endif + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = NULL; + } + } + return c; + } +} + +int +getopt (argc, argv, optstring) + int argc; + char *const *argv; + const char *optstring; +{ + return _getopt_internal (argc, argv, optstring, + (const struct option *) 0, + (int *) 0, + 0); +} + +#endif /* Not ELIDE_CODE. */ + + +/* Compile with -DTEST to make an executable for use in testing + the above definition of `getopt'. */ + +/* #define TEST */ /* Pete Wilson mod 7/28/02 */ +#ifdef TEST + +#ifndef exit /* Pete Wilson mod 7/28/02 */ + int exit(int); /* Pete Wilson mod 7/28/02 */ +#endif /* Pete Wilson mod 7/28/02 */ + +int +main (argc, argv) + int argc; + char **argv; +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == -1) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ + diff --git a/win32/getopt.h b/win32/getopt.h new file mode 100644 index 0000000..f6838fc --- /dev/null +++ b/win32/getopt.h @@ -0,0 +1,187 @@ +/* getopt.h */ +/* Declarations for getopt. + Copyright (C) 1989-1994, 1996-1999, 2001 Free Software + Foundation, Inc. This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute + it and/or modify it under the terms of the GNU Lesser + General Public License as published by the Free Software + Foundation; either version 2.1 of the License, or + (at your option) any later version. + + The GNU C Library is distributed in the hope that it will + be useful, but WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A + PARTICULAR PURPOSE. See the GNU Lesser General Public + License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with the GNU C Library; if not, write + to the Free Software Foundation, Inc., 59 Temple Place, + Suite 330, Boston, MA 02111-1307 USA. */ + + + + +#ifndef _GETOPT_H + +#ifndef __need_getopt +# define _GETOPT_H 1 +#endif + +/* If __GNU_LIBRARY__ is not already defined, either we are being used + standalone, or this is the first header included in the source file. + If we are being used with glibc, we need to include , but + that does not exist if we are standalone. So: if __GNU_LIBRARY__ is + not defined, include , which will pull in for us + if it's from glibc. (Why ctype.h? It's guaranteed to exist and it + doesn't flood the namespace with stuff the way some other headers do.) */ +#if !defined __GNU_LIBRARY__ +# include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +extern char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +extern int optind; + +/* Callers store zero here to inhibit the error message `getopt' prints + for unrecognized options. */ + +extern int opterr; + +/* Set to an option character which was unrecognized. */ + +extern int optopt; + +#ifndef __need_getopt +/* Describe the long-named options requested by the application. + The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector + of `struct option' terminated by an element containing a name which is + zero. + + The field `has_arg' is: + no_argument (or 0) if the option does not take an argument, + required_argument (or 1) if the option requires an argument, + optional_argument (or 2) if the option takes an optional argument. + + If the field `flag' is not NULL, it points to a variable that is set + to the value given in the field `val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an `int' to + a compiled-in constant, such as set a value from `optarg', set the + option's `flag' field to zero and its `val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero `flag' field, `getopt' + returns the contents of the `val' field. */ + +struct option +{ +# if (defined __STDC__ && __STDC__) || defined __cplusplus + const char *name; +# else + char *name; +# endif + /* has_arg can't be an enum because some compilers complain about + type mismatches in all the code that assumes it is an int. */ + int has_arg; + int *flag; + int val; +}; + +/* Names for the values of the `has_arg' field of `struct option'. */ + +# define no_argument 0 +# define required_argument 1 +# define optional_argument 2 +#endif /* need getopt */ + + +/* Get definitions and prototypes for functions to process the + arguments in ARGV (ARGC of them, minus the program name) for + options given in OPTS. + + Return the option character from OPTS just read. Return -1 when + there are no more options. For unrecognized options, or options + missing arguments, `optopt' is set to the option letter, and '?' is + returned. + + The OPTS string is a list of characters which are recognized option + letters, optionally followed by colons, specifying that that letter + takes an argument, to be placed in `optarg'. + + If a letter in OPTS is followed by two colons, its argument is + optional. This behavior is specific to the GNU `getopt'. + + The argument `--' causes premature termination of argument + scanning, explicitly telling `getopt' that there are no more + options. + + If OPTS begins with `--', then non-option arguments are treated as + arguments to the option '\0'. This behavior is specific to the GNU + `getopt'. */ + +#if (defined __STDC__ && __STDC__) || defined __cplusplus +# ifdef __GNU_LIBRARY__ +/* Many other libraries have conflicting prototypes for getopt, with + differences in the consts, in stdlib.h. To avoid compilation + errors, only prototype getopt for the GNU C library. */ +extern int getopt (int ___argc, char *const *___argv, const char *__shortopts); +# else /* not __GNU_LIBRARY__ */ +extern int getopt (); +# endif /* __GNU_LIBRARY__ */ + +# ifndef __need_getopt +extern int getopt_long (int ___argc, char *const *___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind); +extern int getopt_long_only (int ___argc, char *const *___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind); + +/* Internal only. Users should not call this directly. */ +extern int _getopt_internal (int ___argc, char *const *___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind, + int __long_only); +# endif +#else /* not __STDC__ */ +extern int getopt (); +# ifndef __need_getopt +extern int getopt_long (); +extern int getopt_long_only (); + +extern int _getopt_internal (); +# endif +#endif /* __STDC__ */ + +#ifdef __cplusplus +} +#endif + +/* Make sure we later can get all the definitions and declarations. */ +#undef __need_getopt + +#endif /* getopt.h */ diff --git a/win32/unistd.h b/win32/unistd.h new file mode 100644 index 0000000..37c6a13 --- /dev/null +++ b/win32/unistd.h @@ -0,0 +1,26 @@ +#ifndef _UNISTD_H +#define _UNISTD_H 1 + +/* This file intended to serve as a drop-in replacement for + * * unistd.h on Windows + * * Please add functionality as neeeded + * */ + +#include +#include +#include /* getopt from: http://www.pwilson.net/sample.html. */ + +#define srandom srand +#define random rand + +/* +const W_OK = 2; +const R_OK = 4; +*/ + +#define access _access +#define ftruncate _chsize + +#define ssize_t int + +#endif /* unistd.h */ diff --git a/windows_prebuilt_bindings.rs b/windows_prebuilt_bindings.rs new file mode 100644 index 0000000..0be0ebf --- /dev/null +++ b/windows_prebuilt_bindings.rs @@ -0,0 +1,9640 @@ +/* automatically generated by rust-bindgen 0.71.1 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + fn extract_bit(byte: u8, index: usize) -> bool { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize); + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + byte | mask + } else { + byte & !mask + } + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize); + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if Self::raw_get_bit(this, i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + Self::raw_set_bit(this, index + bit_offset, val_bit_is_set); + } + } +} +pub const __MINGW64_VERSION_MAJOR: u32 = 14; +pub const __MINGW64_VERSION_MINOR: u32 = 0; +pub const __MINGW64_VERSION_BUGFIX: u32 = 0; +pub const __MINGW64_VERSION_RC: u32 = 0; +pub const __MINGW64_VERSION_STATE: &[u8; 6] = b"alpha\0"; +pub const __MINGW32_MAJOR_VERSION: u32 = 3; +pub const __MINGW32_MINOR_VERSION: u32 = 11; +pub const _M_AMD64: u32 = 100; +pub const _M_X64: u32 = 100; +pub const __: u32 = 1; +pub const __MINGW_USE_UNDERSCORE_PREFIX: u32 = 0; +pub const __MINGW_HAVE_ANSI_C99_PRINTF: u32 = 1; +pub const __MINGW_HAVE_WIDE_C99_PRINTF: u32 = 1; +pub const __MINGW_HAVE_ANSI_C99_SCANF: u32 = 1; +pub const __MINGW_HAVE_WIDE_C99_SCANF: u32 = 1; +pub const __MINGW_SEC_WARN_STR : & [u8 ; 92] = b"This function or variable may be unsafe, use _CRT_SECURE_NO_WARNINGS to disable deprecation\0" ; +pub const __MINGW_MSVC2005_DEPREC_STR : & [u8 ; 117] = b"This POSIX function is deprecated beginning in Visual C++ 2005, use _CRT_NONSTDC_NO_DEPRECATE to disable deprecation\0" ; +pub const __MINGW_FORTIFY_LEVEL: u32 = 0; +pub const __MINGW_FORTIFY_VA_ARG: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0; +pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0; +pub const __USE_CRTIMP: u32 = 1; +pub const USE___UUIDOF: u32 = 0; +pub const __CRT__NO_INLINE: u32 = 1; +pub const __MSVCRT_VERSION__: u32 = 3584; +pub const _WIN32_WINNT: u32 = 2560; +pub const _CRT_PACKING: u32 = 8; +pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 253; +pub const _ARGMAX: u32 = 100; +pub const __USE_MINGW_ANSI_STDIO: u32 = 0; +pub const __STDC_SECURE_LIB__: u32 = 200411; +pub const __GOT_SECURE_LIB__: u32 = 200411; +pub const INT8_MIN: i32 = -128; +pub const INT16_MIN: i32 = -32768; +pub const INT32_MIN: i32 = -2147483648; +pub const INT64_MIN: i64 = -9223372036854775808; +pub const INT8_MAX: u32 = 127; +pub const INT16_MAX: u32 = 32767; +pub const INT32_MAX: u32 = 2147483647; +pub const INT64_MAX: u64 = 9223372036854775807; +pub const UINT8_MAX: u32 = 255; +pub const UINT16_MAX: u32 = 65535; +pub const UINT32_MAX: u32 = 4294967295; +pub const UINT64_MAX: i32 = -1; +pub const INT_LEAST8_MIN: i32 = -128; +pub const INT_LEAST16_MIN: i32 = -32768; +pub const INT_LEAST32_MIN: i32 = -2147483648; +pub const INT_LEAST64_MIN: i64 = -9223372036854775808; +pub const INT_LEAST8_MAX: u32 = 127; +pub const INT_LEAST16_MAX: u32 = 32767; +pub const INT_LEAST32_MAX: u32 = 2147483647; +pub const INT_LEAST64_MAX: u64 = 9223372036854775807; +pub const UINT_LEAST8_MAX: u32 = 255; +pub const UINT_LEAST16_MAX: u32 = 65535; +pub const UINT_LEAST32_MAX: u32 = 4294967295; +pub const UINT_LEAST64_MAX: i32 = -1; +pub const INT_FAST8_MIN: i32 = -128; +pub const INT_FAST16_MIN: i32 = -32768; +pub const INT_FAST32_MIN: i32 = -2147483648; +pub const INT_FAST64_MIN: i64 = -9223372036854775808; +pub const INT_FAST8_MAX: u32 = 127; +pub const INT_FAST16_MAX: u32 = 32767; +pub const INT_FAST32_MAX: u32 = 2147483647; +pub const INT_FAST64_MAX: u64 = 9223372036854775807; +pub const UINT_FAST8_MAX: u32 = 255; +pub const UINT_FAST16_MAX: u32 = 65535; +pub const UINT_FAST32_MAX: u32 = 4294967295; +pub const UINT_FAST64_MAX: i32 = -1; +pub const INTPTR_MIN: i64 = -9223372036854775808; +pub const INTPTR_MAX: u64 = 9223372036854775807; +pub const UINTPTR_MAX: i32 = -1; +pub const INTMAX_MIN: i64 = -9223372036854775808; +pub const INTMAX_MAX: u64 = 9223372036854775807; +pub const UINTMAX_MAX: i32 = -1; +pub const PTRDIFF_MIN: i64 = -9223372036854775808; +pub const PTRDIFF_MAX: u64 = 9223372036854775807; +pub const SIG_ATOMIC_MIN: i32 = -2147483648; +pub const SIG_ATOMIC_MAX: u32 = 2147483647; +pub const SIZE_MAX: i32 = -1; +pub const WCHAR_MIN: u32 = 0; +pub const WCHAR_MAX: u32 = 65535; +pub const WINT_MIN: u32 = 0; +pub const WINT_MAX: u32 = 65535; +pub const PRId64: &[u8; 4] = b"lld\0"; +pub const PRIi64: &[u8; 4] = b"lli\0"; +pub const PRIo64: &[u8; 4] = b"llo\0"; +pub const PRIu64: &[u8; 4] = b"llu\0"; +pub const PRIx64: &[u8; 4] = b"llx\0"; +pub const PRIX64: &[u8; 4] = b"llX\0"; +pub const PRId8: &[u8; 2] = b"d\0"; +pub const PRId16: &[u8; 2] = b"d\0"; +pub const PRId32: &[u8; 2] = b"d\0"; +pub const PRIdLEAST8: &[u8; 2] = b"d\0"; +pub const PRIdLEAST16: &[u8; 2] = b"d\0"; +pub const PRIdLEAST32: &[u8; 2] = b"d\0"; +pub const PRIdLEAST64: &[u8; 4] = b"lld\0"; +pub const PRIdFAST8: &[u8; 2] = b"d\0"; +pub const PRIdFAST16: &[u8; 2] = b"d\0"; +pub const PRIdFAST32: &[u8; 2] = b"d\0"; +pub const PRIdFAST64: &[u8; 4] = b"lld\0"; +pub const PRIdMAX: &[u8; 4] = b"lld\0"; +pub const PRIi8: &[u8; 2] = b"i\0"; +pub const PRIi16: &[u8; 2] = b"i\0"; +pub const PRIi32: &[u8; 2] = b"i\0"; +pub const PRIiLEAST8: &[u8; 2] = b"i\0"; +pub const PRIiLEAST16: &[u8; 2] = b"i\0"; +pub const PRIiLEAST32: &[u8; 2] = b"i\0"; +pub const PRIiLEAST64: &[u8; 4] = b"lli\0"; +pub const PRIiFAST8: &[u8; 2] = b"i\0"; +pub const PRIiFAST16: &[u8; 2] = b"i\0"; +pub const PRIiFAST32: &[u8; 2] = b"i\0"; +pub const PRIiFAST64: &[u8; 4] = b"lli\0"; +pub const PRIiMAX: &[u8; 4] = b"lli\0"; +pub const PRIo8: &[u8; 2] = b"o\0"; +pub const PRIo16: &[u8; 2] = b"o\0"; +pub const PRIo32: &[u8; 2] = b"o\0"; +pub const PRIoLEAST8: &[u8; 2] = b"o\0"; +pub const PRIoLEAST16: &[u8; 2] = b"o\0"; +pub const PRIoLEAST32: &[u8; 2] = b"o\0"; +pub const PRIoLEAST64: &[u8; 4] = b"llo\0"; +pub const PRIoFAST8: &[u8; 2] = b"o\0"; +pub const PRIoFAST16: &[u8; 2] = b"o\0"; +pub const PRIoFAST32: &[u8; 2] = b"o\0"; +pub const PRIoFAST64: &[u8; 4] = b"llo\0"; +pub const PRIoMAX: &[u8; 4] = b"llo\0"; +pub const PRIu8: &[u8; 2] = b"u\0"; +pub const PRIu16: &[u8; 2] = b"u\0"; +pub const PRIu32: &[u8; 2] = b"u\0"; +pub const PRIuLEAST8: &[u8; 2] = b"u\0"; +pub const PRIuLEAST16: &[u8; 2] = b"u\0"; +pub const PRIuLEAST32: &[u8; 2] = b"u\0"; +pub const PRIuLEAST64: &[u8; 4] = b"llu\0"; +pub const PRIuFAST8: &[u8; 2] = b"u\0"; +pub const PRIuFAST16: &[u8; 2] = b"u\0"; +pub const PRIuFAST32: &[u8; 2] = b"u\0"; +pub const PRIuFAST64: &[u8; 4] = b"llu\0"; +pub const PRIuMAX: &[u8; 4] = b"llu\0"; +pub const PRIx8: &[u8; 2] = b"x\0"; +pub const PRIx16: &[u8; 2] = b"x\0"; +pub const PRIx32: &[u8; 2] = b"x\0"; +pub const PRIxLEAST8: &[u8; 2] = b"x\0"; +pub const PRIxLEAST16: &[u8; 2] = b"x\0"; +pub const PRIxLEAST32: &[u8; 2] = b"x\0"; +pub const PRIxLEAST64: &[u8; 4] = b"llx\0"; +pub const PRIxFAST8: &[u8; 2] = b"x\0"; +pub const PRIxFAST16: &[u8; 2] = b"x\0"; +pub const PRIxFAST32: &[u8; 2] = b"x\0"; +pub const PRIxFAST64: &[u8; 4] = b"llx\0"; +pub const PRIxMAX: &[u8; 4] = b"llx\0"; +pub const PRIX8: &[u8; 2] = b"X\0"; +pub const PRIX16: &[u8; 2] = b"X\0"; +pub const PRIX32: &[u8; 2] = b"X\0"; +pub const PRIXLEAST8: &[u8; 2] = b"X\0"; +pub const PRIXLEAST16: &[u8; 2] = b"X\0"; +pub const PRIXLEAST32: &[u8; 2] = b"X\0"; +pub const PRIXLEAST64: &[u8; 4] = b"llX\0"; +pub const PRIXFAST8: &[u8; 2] = b"X\0"; +pub const PRIXFAST16: &[u8; 2] = b"X\0"; +pub const PRIXFAST32: &[u8; 2] = b"X\0"; +pub const PRIXFAST64: &[u8; 4] = b"llX\0"; +pub const PRIXMAX: &[u8; 4] = b"llX\0"; +pub const SCNd16: &[u8; 3] = b"hd\0"; +pub const SCNd32: &[u8; 2] = b"d\0"; +pub const SCNd64: &[u8; 4] = b"lld\0"; +pub const SCNdLEAST16: &[u8; 3] = b"hd\0"; +pub const SCNdLEAST32: &[u8; 2] = b"d\0"; +pub const SCNdLEAST64: &[u8; 4] = b"lld\0"; +pub const SCNdFAST16: &[u8; 3] = b"hd\0"; +pub const SCNdFAST32: &[u8; 2] = b"d\0"; +pub const SCNdFAST64: &[u8; 4] = b"lld\0"; +pub const SCNdMAX: &[u8; 4] = b"lld\0"; +pub const SCNi16: &[u8; 3] = b"hi\0"; +pub const SCNi32: &[u8; 2] = b"i\0"; +pub const SCNi64: &[u8; 4] = b"lli\0"; +pub const SCNiLEAST16: &[u8; 3] = b"hi\0"; +pub const SCNiLEAST32: &[u8; 2] = b"i\0"; +pub const SCNiLEAST64: &[u8; 4] = b"lli\0"; +pub const SCNiFAST16: &[u8; 3] = b"hi\0"; +pub const SCNiFAST32: &[u8; 2] = b"i\0"; +pub const SCNiFAST64: &[u8; 4] = b"lli\0"; +pub const SCNiMAX: &[u8; 4] = b"lli\0"; +pub const SCNo16: &[u8; 3] = b"ho\0"; +pub const SCNo32: &[u8; 2] = b"o\0"; +pub const SCNo64: &[u8; 4] = b"llo\0"; +pub const SCNoLEAST16: &[u8; 3] = b"ho\0"; +pub const SCNoLEAST32: &[u8; 2] = b"o\0"; +pub const SCNoLEAST64: &[u8; 4] = b"llo\0"; +pub const SCNoFAST16: &[u8; 3] = b"ho\0"; +pub const SCNoFAST32: &[u8; 2] = b"o\0"; +pub const SCNoFAST64: &[u8; 4] = b"llo\0"; +pub const SCNoMAX: &[u8; 4] = b"llo\0"; +pub const SCNx16: &[u8; 3] = b"hx\0"; +pub const SCNx32: &[u8; 2] = b"x\0"; +pub const SCNx64: &[u8; 4] = b"llx\0"; +pub const SCNxLEAST16: &[u8; 3] = b"hx\0"; +pub const SCNxLEAST32: &[u8; 2] = b"x\0"; +pub const SCNxLEAST64: &[u8; 4] = b"llx\0"; +pub const SCNxFAST16: &[u8; 3] = b"hx\0"; +pub const SCNxFAST32: &[u8; 2] = b"x\0"; +pub const SCNxFAST64: &[u8; 4] = b"llx\0"; +pub const SCNxMAX: &[u8; 4] = b"llx\0"; +pub const SCNu16: &[u8; 3] = b"hu\0"; +pub const SCNu32: &[u8; 2] = b"u\0"; +pub const SCNu64: &[u8; 4] = b"llu\0"; +pub const SCNuLEAST16: &[u8; 3] = b"hu\0"; +pub const SCNuLEAST32: &[u8; 2] = b"u\0"; +pub const SCNuLEAST64: &[u8; 4] = b"llu\0"; +pub const SCNuFAST16: &[u8; 3] = b"hu\0"; +pub const SCNuFAST32: &[u8; 2] = b"u\0"; +pub const SCNuFAST64: &[u8; 4] = b"llu\0"; +pub const SCNuMAX: &[u8; 4] = b"llu\0"; +pub const PRIdPTR: &[u8; 4] = b"lld\0"; +pub const PRIiPTR: &[u8; 4] = b"lli\0"; +pub const PRIoPTR: &[u8; 4] = b"llo\0"; +pub const PRIuPTR: &[u8; 4] = b"llu\0"; +pub const PRIxPTR: &[u8; 4] = b"llx\0"; +pub const PRIXPTR: &[u8; 4] = b"llX\0"; +pub const SCNdPTR: &[u8; 4] = b"lld\0"; +pub const SCNiPTR: &[u8; 4] = b"lli\0"; +pub const SCNoPTR: &[u8; 4] = b"llo\0"; +pub const SCNxPTR: &[u8; 4] = b"llx\0"; +pub const SCNuPTR: &[u8; 4] = b"llu\0"; +pub const SCNd8: &[u8; 4] = b"hhd\0"; +pub const SCNdLEAST8: &[u8; 4] = b"hhd\0"; +pub const SCNdFAST8: &[u8; 4] = b"hhd\0"; +pub const SCNi8: &[u8; 4] = b"hhi\0"; +pub const SCNiLEAST8: &[u8; 4] = b"hhi\0"; +pub const SCNiFAST8: &[u8; 4] = b"hhi\0"; +pub const SCNo8: &[u8; 4] = b"hho\0"; +pub const SCNoLEAST8: &[u8; 4] = b"hho\0"; +pub const SCNoFAST8: &[u8; 4] = b"hho\0"; +pub const SCNx8: &[u8; 4] = b"hhx\0"; +pub const SCNxLEAST8: &[u8; 4] = b"hhx\0"; +pub const SCNxFAST8: &[u8; 4] = b"hhx\0"; +pub const SCNu8: &[u8; 4] = b"hhu\0"; +pub const SCNuLEAST8: &[u8; 4] = b"hhu\0"; +pub const SCNuFAST8: &[u8; 4] = b"hhu\0"; +pub const _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION: u32 = 1; +pub const _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR: u32 = 2; +pub const _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS: u32 = 4; +pub const _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 8; +pub const _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS: u32 = 16; +pub const _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING: u32 = 32; +pub const _CRT_INTERNAL_SCANF_SECURECRT: u32 = 1; +pub const _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS: u32 = 2; +pub const _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 4; +pub const BUFSIZ: u32 = 512; +pub const _NSTREAM_: u32 = 512; +pub const _IOB_ENTRIES: u32 = 20; +pub const EOF: i32 = -1; +pub const _P_tmpdir: &[u8; 2] = b"\\\0"; +pub const _wP_tmpdir: &[u8; 2] = b"\\\0"; +pub const L_tmpnam: u32 = 260; +pub const SEEK_CUR: u32 = 1; +pub const SEEK_END: u32 = 2; +pub const SEEK_SET: u32 = 0; +pub const STDIN_FILENO: u32 = 0; +pub const STDOUT_FILENO: u32 = 1; +pub const STDERR_FILENO: u32 = 2; +pub const FILENAME_MAX: u32 = 260; +pub const FOPEN_MAX: u32 = 20; +pub const _SYS_OPEN: u32 = 20; +pub const TMP_MAX: u32 = 2147483647; +pub const _IOFBF: u32 = 0; +pub const _IOLBF: u32 = 64; +pub const _IONBF: u32 = 4; +pub const P_tmpdir: &[u8; 2] = b"\\\0"; +pub const SYS_OPEN: u32 = 20; +pub const _P_WAIT: u32 = 0; +pub const _P_NOWAIT: u32 = 1; +pub const _OLD_P_OVERLAY: u32 = 2; +pub const _P_NOWAITO: u32 = 3; +pub const _P_DETACH: u32 = 4; +pub const _P_OVERLAY: u32 = 2; +pub const _WAIT_CHILD: u32 = 0; +pub const _WAIT_GRANDCHILD: u32 = 1; +pub const L_tmpnam_s: u32 = 260; +pub const TMP_MAX_S: u32 = 2147483647; +pub const PATH_MAX: u32 = 260; +pub const CHAR_BIT: u32 = 8; +pub const SCHAR_MIN: i32 = -128; +pub const SCHAR_MAX: u32 = 127; +pub const UCHAR_MAX: u32 = 255; +pub const CHAR_MIN: i32 = -128; +pub const CHAR_MAX: u32 = 127; +pub const MB_LEN_MAX: u32 = 5; +pub const SHRT_MIN: i32 = -32768; +pub const SHRT_MAX: u32 = 32767; +pub const USHRT_MAX: u32 = 65535; +pub const INT_MIN: i32 = -2147483648; +pub const INT_MAX: u32 = 2147483647; +pub const UINT_MAX: u32 = 4294967295; +pub const LONG_MIN: i32 = -2147483648; +pub const LONG_MAX: u32 = 2147483647; +pub const ULONG_MAX: u32 = 4294967295; +pub const LLONG_MAX: u64 = 9223372036854775807; +pub const LLONG_MIN: i64 = -9223372036854775808; +pub const ULLONG_MAX: i32 = -1; +pub const _I8_MIN: i32 = -128; +pub const _I8_MAX: u32 = 127; +pub const _UI8_MAX: u32 = 255; +pub const _I16_MIN: i32 = -32768; +pub const _I16_MAX: u32 = 32767; +pub const _UI16_MAX: u32 = 65535; +pub const _I32_MIN: i32 = -2147483648; +pub const _I32_MAX: u32 = 2147483647; +pub const _UI32_MAX: u32 = 4294967295; +pub const LONG_LONG_MAX: u64 = 9223372036854775807; +pub const LONG_LONG_MIN: i64 = -9223372036854775808; +pub const ULONG_LONG_MAX: i32 = -1; +pub const _I64_MIN: i64 = -9223372036854775808; +pub const _I64_MAX: u64 = 9223372036854775807; +pub const _UI64_MAX: i32 = -1; +pub const SSIZE_MAX: u64 = 9223372036854775807; +pub const EXIT_SUCCESS: u32 = 0; +pub const EXIT_FAILURE: u32 = 1; +pub const RAND_MAX: u32 = 32767; +pub const _MAX_PATH: u32 = 260; +pub const _MAX_DRIVE: u32 = 3; +pub const _MAX_DIR: u32 = 256; +pub const _MAX_FNAME: u32 = 256; +pub const _MAX_EXT: u32 = 256; +pub const _OUT_TO_DEFAULT: u32 = 0; +pub const _OUT_TO_STDERR: u32 = 1; +pub const _OUT_TO_MSGBOX: u32 = 2; +pub const _REPORT_ERRMODE: u32 = 3; +pub const _WRITE_ABORT_MSG: u32 = 1; +pub const _CALL_REPORTFAULT: u32 = 2; +pub const _MAX_ENV: u32 = 32767; +pub const _CVTBUFSIZE: u32 = 349; +pub const _HEAP_MAXREQ: i32 = -32; +pub const _HEAPEMPTY: i32 = -1; +pub const _HEAPOK: i32 = -2; +pub const _HEAPBADBEGIN: i32 = -3; +pub const _HEAPBADNODE: i32 = -4; +pub const _HEAPEND: i32 = -5; +pub const _HEAPBADPTR: i32 = -6; +pub const _FREEENTRY: u32 = 0; +pub const _USEDENTRY: u32 = 1; +pub const _MAX_WAIT_MALLOC_CRT: u32 = 60000; +pub const _ALLOCA_S_THRESHOLD: u32 = 1024; +pub const _ALLOCA_S_STACK_MARKER: u32 = 52428; +pub const _ALLOCA_S_HEAP_MARKER: u32 = 56797; +pub const _ALLOCA_S_MARKER_SIZE: u32 = 16; +pub const _NLSCMPERROR: u32 = 2147483647; +pub const EPERM: u32 = 1; +pub const ENOENT: u32 = 2; +pub const ENOFILE: u32 = 2; +pub const ESRCH: u32 = 3; +pub const EINTR: u32 = 4; +pub const EIO: u32 = 5; +pub const ENXIO: u32 = 6; +pub const E2BIG: u32 = 7; +pub const ENOEXEC: u32 = 8; +pub const EBADF: u32 = 9; +pub const ECHILD: u32 = 10; +pub const EAGAIN: u32 = 11; +pub const ENOMEM: u32 = 12; +pub const EACCES: u32 = 13; +pub const EFAULT: u32 = 14; +pub const EBUSY: u32 = 16; +pub const EEXIST: u32 = 17; +pub const EXDEV: u32 = 18; +pub const ENODEV: u32 = 19; +pub const ENOTDIR: u32 = 20; +pub const EISDIR: u32 = 21; +pub const ENFILE: u32 = 23; +pub const EMFILE: u32 = 24; +pub const ENOTTY: u32 = 25; +pub const EFBIG: u32 = 27; +pub const ENOSPC: u32 = 28; +pub const ESPIPE: u32 = 29; +pub const EROFS: u32 = 30; +pub const EMLINK: u32 = 31; +pub const EPIPE: u32 = 32; +pub const EDOM: u32 = 33; +pub const EDEADLK: u32 = 36; +pub const ENAMETOOLONG: u32 = 38; +pub const ENOLCK: u32 = 39; +pub const ENOSYS: u32 = 40; +pub const ENOTEMPTY: u32 = 41; +pub const EINVAL: u32 = 22; +pub const ERANGE: u32 = 34; +pub const EILSEQ: u32 = 42; +pub const STRUNCATE: u32 = 80; +pub const EDEADLOCK: u32 = 36; +pub const ENOTSUP: u32 = 129; +pub const EAFNOSUPPORT: u32 = 102; +pub const EADDRINUSE: u32 = 100; +pub const EADDRNOTAVAIL: u32 = 101; +pub const EISCONN: u32 = 113; +pub const ENOBUFS: u32 = 119; +pub const ECONNABORTED: u32 = 106; +pub const EALREADY: u32 = 103; +pub const ECONNREFUSED: u32 = 107; +pub const ECONNRESET: u32 = 108; +pub const EDESTADDRREQ: u32 = 109; +pub const EHOSTUNREACH: u32 = 110; +pub const EMSGSIZE: u32 = 115; +pub const ENETDOWN: u32 = 116; +pub const ENETRESET: u32 = 117; +pub const ENETUNREACH: u32 = 118; +pub const ENOPROTOOPT: u32 = 123; +pub const ENOTSOCK: u32 = 128; +pub const ENOTCONN: u32 = 126; +pub const ECANCELED: u32 = 105; +pub const EINPROGRESS: u32 = 112; +pub const EOPNOTSUPP: u32 = 130; +pub const EWOULDBLOCK: u32 = 140; +pub const EOWNERDEAD: u32 = 133; +pub const EPROTO: u32 = 134; +pub const EPROTONOSUPPORT: u32 = 135; +pub const EBADMSG: u32 = 104; +pub const EIDRM: u32 = 111; +pub const ENODATA: u32 = 120; +pub const ENOLINK: u32 = 121; +pub const ENOMSG: u32 = 122; +pub const ENOSR: u32 = 124; +pub const ENOSTR: u32 = 125; +pub const ENOTRECOVERABLE: u32 = 127; +pub const ETIME: u32 = 137; +pub const ETXTBSY: u32 = 139; +pub const ETIMEDOUT: u32 = 138; +pub const ELOOP: u32 = 114; +pub const EPROTOTYPE: u32 = 136; +pub const EOVERFLOW: u32 = 132; +pub const HAVE___BUILTIN_CLZ: u32 = 1; +pub const HTS_PATH_SEPARATOR_CHAR: u8 = 59u8; +pub const HTS_PATH_SEPARATOR_STR: &[u8; 2] = b";\0"; +pub const HTS_RESIZE_CLEAR: u32 = 1; +pub const HTS_IDX_DELIM: &[u8; 8] = b"##idx##\0"; +pub const HTS_VERSION: u32 = 101901; +pub const HTS_FEATURE_CONFIGURE: u32 = 1; +pub const HTS_FEATURE_PLUGINS: u32 = 2; +pub const HTS_FEATURE_LIBCURL: u32 = 1024; +pub const HTS_FEATURE_S3: u32 = 2048; +pub const HTS_FEATURE_GCS: u32 = 4096; +pub const HTS_FEATURE_LIBDEFLATE: u32 = 1048576; +pub const HTS_FEATURE_LZMA: u32 = 2097152; +pub const HTS_FEATURE_BZIP2: u32 = 4194304; +pub const HTS_FEATURE_HTSCODECS: u32 = 8388608; +pub const HTS_FEATURE_CC: u32 = 134217728; +pub const HTS_FEATURE_CFLAGS: u32 = 268435456; +pub const HTS_FEATURE_CPPFLAGS: u32 = 536870912; +pub const HTS_FEATURE_LDFLAGS: u32 = 1073741824; +pub const HTS_IDX_NOCOOR: i32 = -2; +pub const HTS_IDX_START: i32 = -3; +pub const HTS_IDX_REST: i32 = -4; +pub const HTS_IDX_NONE: i32 = -5; +pub const HTS_FMT_CSI: u32 = 0; +pub const HTS_FMT_BAI: u32 = 1; +pub const HTS_FMT_TBI: u32 = 2; +pub const HTS_FMT_CRAI: u32 = 3; +pub const HTS_FMT_FAI: u32 = 4; +pub const HTS_POS_MIN: i64 = -9223372036854775808; +pub const PRIhts_pos: &[u8; 4] = b"lld\0"; +pub const HTS_IDX_SAVE_REMOTE: u32 = 1; +pub const HTS_IDX_SILENT_FAIL: u32 = 2; +pub const HTS_PARSE_THOUSANDS_SEP: u32 = 1; +pub const HTS_PARSE_ONE_COORD: u32 = 2; +pub const HTS_PARSE_LIST: u32 = 4; +pub const FT_UNKN: u32 = 0; +pub const FT_GZ: u32 = 1; +pub const FT_VCF: u32 = 2; +pub const FT_VCF_GZ: u32 = 3; +pub const FT_BCF: u32 = 4; +pub const FT_BCF_GZ: u32 = 5; +pub const FT_STDIN: u32 = 8; +pub const HTS_ALLOW_UNALIGNED: u32 = 1; +pub const BCF_HL_FLT: u32 = 0; +pub const BCF_HL_INFO: u32 = 1; +pub const BCF_HL_FMT: u32 = 2; +pub const BCF_HL_CTG: u32 = 3; +pub const BCF_HL_STR: u32 = 4; +pub const BCF_HL_GEN: u32 = 5; +pub const BCF_HT_FLAG: u32 = 0; +pub const BCF_HT_INT: u32 = 1; +pub const BCF_HT_REAL: u32 = 2; +pub const BCF_HT_STR: u32 = 3; +pub const BCF_HT_LONG: u32 = 257; +pub const BCF_VL_FIXED: u32 = 0; +pub const BCF_VL_VAR: u32 = 1; +pub const BCF_VL_A: u32 = 2; +pub const BCF_VL_G: u32 = 3; +pub const BCF_VL_R: u32 = 4; +pub const BCF_DT_ID: u32 = 0; +pub const BCF_DT_CTG: u32 = 1; +pub const BCF_DT_SAMPLE: u32 = 2; +pub const BCF_BT_NULL: u32 = 0; +pub const BCF_BT_INT8: u32 = 1; +pub const BCF_BT_INT16: u32 = 2; +pub const BCF_BT_INT32: u32 = 3; +pub const BCF_BT_INT64: u32 = 4; +pub const BCF_BT_FLOAT: u32 = 5; +pub const BCF_BT_CHAR: u32 = 7; +pub const VCF_REF: u32 = 0; +pub const VCF_SNP: u32 = 1; +pub const VCF_MNP: u32 = 2; +pub const VCF_INDEL: u32 = 4; +pub const VCF_OTHER: u32 = 8; +pub const VCF_BND: u32 = 16; +pub const VCF_OVERLAP: u32 = 32; +pub const VCF_INS: u32 = 64; +pub const VCF_DEL: u32 = 128; +pub const VCF_ANY: u32 = 255; +pub const BCF1_DIRTY_ID: u32 = 1; +pub const BCF1_DIRTY_ALS: u32 = 2; +pub const BCF1_DIRTY_FLT: u32 = 4; +pub const BCF1_DIRTY_INF: u32 = 8; +pub const BCF_ERR_CTG_UNDEF: u32 = 1; +pub const BCF_ERR_TAG_UNDEF: u32 = 2; +pub const BCF_ERR_NCOLS: u32 = 4; +pub const BCF_ERR_LIMITS: u32 = 8; +pub const BCF_ERR_CHAR: u32 = 16; +pub const BCF_ERR_CTG_INVALID: u32 = 32; +pub const BCF_ERR_TAG_INVALID: u32 = 64; +pub const BCF_UN_STR: u32 = 1; +pub const BCF_UN_FLT: u32 = 2; +pub const BCF_UN_INFO: u32 = 4; +pub const BCF_UN_SHR: u32 = 7; +pub const BCF_UN_FMT: u32 = 8; +pub const BCF_UN_IND: u32 = 8; +pub const BCF_UN_ALL: u32 = 15; +pub const bcf_gt_missing: u32 = 0; +pub const bcf_int8_vector_end: i32 = -127; +pub const bcf_int16_vector_end: i32 = -32767; +pub const bcf_int32_vector_end: i32 = -2147483647; +pub const bcf_int64_vector_end: i64 = -9223372036854775807; +pub const bcf_str_vector_end: u32 = 0; +pub const bcf_int8_missing: i32 = -128; +pub const bcf_int16_missing: i32 = -32768; +pub const bcf_int32_missing: i32 = -2147483648; +pub const bcf_int64_missing: i64 = -9223372036854775808; +pub const bcf_str_missing: u32 = 7; +pub const BCF_MAX_BT_INT8: u32 = 127; +pub const BCF_MAX_BT_INT16: u32 = 32767; +pub const BCF_MAX_BT_INT32: u32 = 2147483647; +pub const BCF_MIN_BT_INT8: i32 = -120; +pub const BCF_MIN_BT_INT16: i32 = -32760; +pub const BCF_MIN_BT_INT32: i32 = -2147483640; +pub const SAM_FORMAT_VERSION: &[u8; 4] = b"1.6\0"; +pub const BAM_CMATCH: u32 = 0; +pub const BAM_CINS: u32 = 1; +pub const BAM_CDEL: u32 = 2; +pub const BAM_CREF_SKIP: u32 = 3; +pub const BAM_CSOFT_CLIP: u32 = 4; +pub const BAM_CHARD_CLIP: u32 = 5; +pub const BAM_CPAD: u32 = 6; +pub const BAM_CEQUAL: u32 = 7; +pub const BAM_CDIFF: u32 = 8; +pub const BAM_CBACK: u32 = 9; +pub const BAM_CIGAR_STR: &[u8; 11] = b"MIDNSHP=XB\0"; +pub const BAM_CIGAR_SHIFT: u32 = 4; +pub const BAM_CIGAR_MASK: u32 = 15; +pub const BAM_CIGAR_TYPE: u32 = 246183; +pub const BAM_FPAIRED: u32 = 1; +pub const BAM_FPROPER_PAIR: u32 = 2; +pub const BAM_FUNMAP: u32 = 4; +pub const BAM_FMUNMAP: u32 = 8; +pub const BAM_FREVERSE: u32 = 16; +pub const BAM_FMREVERSE: u32 = 32; +pub const BAM_FREAD1: u32 = 64; +pub const BAM_FREAD2: u32 = 128; +pub const BAM_FSECONDARY: u32 = 256; +pub const BAM_FQCFAIL: u32 = 512; +pub const BAM_FDUP: u32 = 1024; +pub const BAM_FSUPPLEMENTARY: u32 = 2048; +pub const BAM_USER_OWNS_STRUCT: u32 = 1; +pub const BAM_USER_OWNS_DATA: u32 = 2; +pub const HTS_MOD_UNKNOWN: i32 = -1; +pub const HTS_MOD_UNCHECKED: i32 = -2; +pub const HTS_MOD_REPORT_UNCHECKED: u32 = 1; +pub const BGZF_BLOCK_SIZE: u32 = 65280; +pub const BGZF_MAX_BLOCK_SIZE: u32 = 65536; +pub const BGZF_ERR_ZLIB: u32 = 1; +pub const BGZF_ERR_HEADER: u32 = 2; +pub const BGZF_ERR_IO: u32 = 4; +pub const BGZF_ERR_MISUSE: u32 = 8; +pub const BGZF_ERR_MT: u32 = 16; +pub const BGZF_ERR_CRC: u32 = 32; +pub const GT_HOM_RR: u32 = 0; +pub const GT_HOM_AA: u32 = 1; +pub const GT_HET_RA: u32 = 2; +pub const GT_HET_AA: u32 = 3; +pub const GT_HAPL_R: u32 = 4; +pub const GT_HAPL_A: u32 = 5; +pub const GT_UNKN: u32 = 6; +pub const TBX_MAX_SHIFT: u32 = 31; +pub const TBX_GENERIC: u32 = 0; +pub const TBX_SAM: u32 = 1; +pub const TBX_VCF: u32 = 2; +pub const TBX_UCSC: u32 = 65536; +pub const COLLAPSE_NONE: u32 = 0; +pub const COLLAPSE_SNPS: u32 = 1; +pub const COLLAPSE_INDELS: u32 = 2; +pub const COLLAPSE_ANY: u32 = 4; +pub const COLLAPSE_SOME: u32 = 8; +pub const COLLAPSE_BOTH: u32 = 3; +pub const BCF_SR_PAIR_SNPS: u32 = 1; +pub const BCF_SR_PAIR_INDELS: u32 = 2; +pub const BCF_SR_PAIR_ANY: u32 = 4; +pub const BCF_SR_PAIR_SOME: u32 = 8; +pub const BCF_SR_PAIR_SNP_REF: u32 = 16; +pub const BCF_SR_PAIR_INDEL_REF: u32 = 32; +pub const BCF_SR_PAIR_EXACT: u32 = 64; +pub const BCF_SR_PAIR_BOTH: u32 = 3; +pub const BCF_SR_PAIR_BOTH_REF: u32 = 51; +pub type wchar_t = ::std::os::raw::c_ushort; +pub type __gnuc_va_list = __builtin_va_list; +pub type va_list = __gnuc_va_list; +unsafe extern "C" { + pub fn __mingw_get_crt_info() -> *const ::std::os::raw::c_char; +} +pub type rsize_t = usize; +pub type wint_t = ::std::os::raw::c_ushort; +pub type wctype_t = ::std::os::raw::c_ushort; +pub type errno_t = ::std::os::raw::c_int; +pub type __time32_t = ::std::os::raw::c_long; +pub type __time64_t = ::std::os::raw::c_longlong; +pub type time_t = __time64_t; +unsafe extern "C" { + pub fn _invalid_parameter_noinfo(); +} +unsafe extern "C" { + pub fn _invalid_parameter_noinfo_noreturn() -> !; +} +unsafe extern "C" { + pub fn _invoke_watson( + expression: *const wchar_t, + function_name: *const wchar_t, + file_name: *const wchar_t, + line_number: ::std::os::raw::c_uint, + reserved: ::std::os::raw::c_ulonglong, + ) -> !; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct threadmbcinfostruct { + _unused: [u8; 0], +} +pub type pthreadlocinfo = *mut threadlocaleinfostruct; +pub type pthreadmbcinfo = *mut threadmbcinfostruct; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __lc_time_data { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct localeinfo_struct { + pub locinfo: pthreadlocinfo, + pub mbcinfo: pthreadmbcinfo, +} +pub type _locale_tstruct = localeinfo_struct; +pub type _locale_t = *mut localeinfo_struct; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tagLC_ID { + pub wLanguage: ::std::os::raw::c_ushort, + pub wCountry: ::std::os::raw::c_ushort, + pub wCodePage: ::std::os::raw::c_ushort, +} +pub type LC_ID = tagLC_ID; +pub type LPLC_ID = *mut tagLC_ID; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct threadlocaleinfostruct { + pub _locale_pctype: *const ::std::os::raw::c_ushort, + pub _locale_mb_cur_max: ::std::os::raw::c_int, + pub _locale_lc_codepage: ::std::os::raw::c_uint, +} +pub type threadlocinfo = threadlocaleinfostruct; +pub type int_least8_t = ::std::os::raw::c_schar; +pub type uint_least8_t = ::std::os::raw::c_uchar; +pub type int_least16_t = ::std::os::raw::c_short; +pub type uint_least16_t = ::std::os::raw::c_ushort; +pub type int_least32_t = ::std::os::raw::c_int; +pub type uint_least32_t = ::std::os::raw::c_uint; +pub type int_least64_t = ::std::os::raw::c_longlong; +pub type uint_least64_t = ::std::os::raw::c_ulonglong; +pub type int_fast8_t = ::std::os::raw::c_schar; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type int_fast16_t = ::std::os::raw::c_short; +pub type uint_fast16_t = ::std::os::raw::c_ushort; +pub type int_fast32_t = ::std::os::raw::c_int; +pub type uint_fast32_t = ::std::os::raw::c_uint; +pub type int_fast64_t = ::std::os::raw::c_longlong; +pub type uint_fast64_t = ::std::os::raw::c_ulonglong; +pub type intmax_t = ::std::os::raw::c_longlong; +pub type uintmax_t = ::std::os::raw::c_ulonglong; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct imaxdiv_t { + pub quot: intmax_t, + pub rem: intmax_t, +} +unsafe extern "C" { + pub fn imaxabs(j: intmax_t) -> intmax_t; +} +unsafe extern "C" { + pub fn imaxdiv(numer: intmax_t, denom: intmax_t) -> imaxdiv_t; +} +unsafe extern "C" { + pub fn strtoimax( + nptr: *const ::std::os::raw::c_char, + endptr: *mut *mut ::std::os::raw::c_char, + base: ::std::os::raw::c_int, + ) -> intmax_t; +} +unsafe extern "C" { + pub fn strtoumax( + nptr: *const ::std::os::raw::c_char, + endptr: *mut *mut ::std::os::raw::c_char, + base: ::std::os::raw::c_int, + ) -> uintmax_t; +} +unsafe extern "C" { + pub fn wcstoimax( + nptr: *const wchar_t, + endptr: *mut *mut wchar_t, + base: ::std::os::raw::c_int, + ) -> intmax_t; +} +unsafe extern "C" { + pub fn wcstoumax( + nptr: *const wchar_t, + endptr: *mut *mut wchar_t, + base: ::std::os::raw::c_int, + ) -> uintmax_t; +} +unsafe extern "C" { + pub fn __local_stdio_printf_options() -> *mut ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn __local_stdio_scanf_options() -> *mut ::std::os::raw::c_ulonglong; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _iobuf { + pub _Placeholder: *mut ::std::os::raw::c_void, +} +pub type FILE = _iobuf; +pub type _off_t = ::std::os::raw::c_long; +pub type off32_t = ::std::os::raw::c_long; +pub type _off64_t = ::std::os::raw::c_longlong; +pub type off64_t = ::std::os::raw::c_longlong; +pub type off_t = off32_t; +unsafe extern "C" { + pub fn __acrt_iob_func(index: ::std::os::raw::c_uint) -> *mut FILE; +} +unsafe extern "C" { + pub fn __iob_func() -> *mut FILE; +} +pub type fpos_t = ::std::os::raw::c_longlong; +unsafe extern "C" { + pub fn __mingw_sscanf( + _Src: *const ::std::os::raw::c_char, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vsscanf( + _Str: *const ::std::os::raw::c_char, + Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_scanf(_Format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vscanf( + Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_fscanf( + _File: *mut FILE, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vfscanf( + fp: *mut FILE, + Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vsnprintf( + _DstBuf: *mut ::std::os::raw::c_char, + _MaxCount: usize, + _Format: *const ::std::os::raw::c_char, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_snprintf( + s: *mut ::std::os::raw::c_char, + n: usize, + format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vprintf( + arg1: *const ::std::os::raw::c_char, + arg2: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_fprintf( + arg1: *mut FILE, + arg2: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vfprintf( + arg1: *mut FILE, + arg2: *const ::std::os::raw::c_char, + arg3: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_sprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vsprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_asprintf( + arg1: *mut *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vasprintf( + arg1: *mut *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}sscanf"] + pub fn __ms_sscanf( + _Src: *const ::std::os::raw::c_char, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vsscanf"] + pub fn __ms_vsscanf( + _Str: *const ::std::os::raw::c_char, + _Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}scanf"] + pub fn __ms_scanf(_Format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vscanf"] + pub fn __ms_vscanf( + _Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}fscanf"] + pub fn __ms_fscanf( + _File: *mut FILE, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vfscanf"] + pub fn __ms_vfscanf( + _File: *mut FILE, + _Format: *const ::std::os::raw::c_char, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}printf"] + pub fn __ms_printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vprintf"] + pub fn __ms_vprintf( + arg1: *const ::std::os::raw::c_char, + arg2: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}fprintf"] + pub fn __ms_fprintf( + arg1: *mut FILE, + arg2: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vfprintf"] + pub fn __ms_vfprintf( + arg1: *mut FILE, + arg2: *const ::std::os::raw::c_char, + arg3: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}sprintf"] + pub fn __ms_sprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vsprintf"] + pub fn __ms_vsprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}snprintf"] + pub fn __ms_snprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: usize, + arg3: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vsnprintf"] + pub fn __ms_vsnprintf( + arg1: *mut ::std::os::raw::c_char, + arg2: usize, + arg3: *const ::std::os::raw::c_char, + arg4: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vsprintf( + options: ::std::os::raw::c_ulonglong, + str_: *mut ::std::os::raw::c_char, + len: usize, + format: *const ::std::os::raw::c_char, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfprintf( + options: ::std::os::raw::c_ulonglong, + file: *mut FILE, + format: *const ::std::os::raw::c_char, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vsscanf( + options: ::std::os::raw::c_ulonglong, + input: *const ::std::os::raw::c_char, + length: usize, + format: *const ::std::os::raw::c_char, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfscanf( + options: ::std::os::raw::c_ulonglong, + file: *mut FILE, + format: *const ::std::os::raw::c_char, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _filbuf(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _flsbuf(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fsopen( + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + _ShFlag: ::std::os::raw::c_int, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn clearerr(_File: *mut FILE); +} +unsafe extern "C" { + pub fn fclose(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fcloseall() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fdopen( + _FileHandle: ::std::os::raw::c_int, + _Mode: *const ::std::os::raw::c_char, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn feof(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ferror(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fflush(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fgetc(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fgetchar() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fgetpos(_File: *mut FILE, _Pos: *mut fpos_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fgetpos64(_File: *mut FILE, _Pos: *mut fpos_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fgets( + _Buf: *mut ::std::os::raw::c_char, + _MaxCount: ::std::os::raw::c_int, + _File: *mut FILE, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _fileno(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _tempnam( + _DirName: *const ::std::os::raw::c_char, + _FilePrefix: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _flushall() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fopen( + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn fopen64( + filename: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn fputc(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fputchar(_Ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fputs(_Str: *const ::std::os::raw::c_char, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fread( + _DstBuf: *mut ::std::os::raw::c_void, + _ElementSize: ::std::os::raw::c_ulonglong, + _Count: ::std::os::raw::c_ulonglong, + _File: *mut FILE, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn freopen( + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + _File: *mut FILE, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn freopen64( + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + _File: *mut FILE, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn fsetpos(_File: *mut FILE, _Pos: *const fpos_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fsetpos64(_File: *mut FILE, _Pos: *const fpos_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fseek( + _File: *mut FILE, + _Offset: ::std::os::raw::c_long, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ftell(_File: *mut FILE) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _fseeki64( + _File: *mut FILE, + _Offset: ::std::os::raw::c_longlong, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _ftelli64(_File: *mut FILE) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn fseeko( + _File: *mut FILE, + _Offset: _off_t, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fseeko64( + _File: *mut FILE, + _Offset: _off64_t, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ftello(_File: *mut FILE) -> _off_t; +} +unsafe extern "C" { + pub fn ftello64(_File: *mut FILE) -> _off64_t; +} +unsafe extern "C" { + pub fn fwrite( + _Str: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + _Count: ::std::os::raw::c_ulonglong, + _File: *mut FILE, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn getc(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn getchar() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _getmaxstdio() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn gets(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _getw(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn perror(_ErrMsg: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn _pclose(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _popen( + _Command: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn putc(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn putchar(_Ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn puts(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _putw(_Word: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn remove(_Filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn rename( + _OldFilename: *const ::std::os::raw::c_char, + _NewFilename: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _unlink(_Filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn unlink(_Filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn rewind(_File: *mut FILE); +} +unsafe extern "C" { + pub fn _rmtmp() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn setbuf(_File: *mut FILE, _Buffer: *mut ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn _setmaxstdio(_Max: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_output_format(_Format: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn _get_output_format() -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn setvbuf( + _File: *mut FILE, + _Buf: *mut ::std::os::raw::c_char, + _Mode: ::std::os::raw::c_int, + _Size: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _scprintf(_Format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _snscanf( + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _vscprintf( + _Format: *const ::std::os::raw::c_char, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tmpfile() -> *mut FILE; +} +unsafe extern "C" { + pub fn tmpfile64() -> *mut FILE; +} +unsafe extern "C" { + pub fn tmpnam(_Buffer: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn ungetc(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _vsnprintf( + _Dest: *mut ::std::os::raw::c_char, + _Count: usize, + _Format: *const ::std::os::raw::c_char, + _Args: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _snprintf( + _Dest: *mut ::std::os::raw::c_char, + _Count: usize, + _Format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_printf_count_output(_Value: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _get_printf_count_output() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_swscanf( + _Src: *const wchar_t, + _Format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vswscanf( + _Str: *const wchar_t, + Format: *const wchar_t, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_wscanf(_Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vwscanf(Format: *const wchar_t, argp: va_list) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_fwscanf(_File: *mut FILE, _Format: *const wchar_t, ...) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vfwscanf( + fp: *mut FILE, + Format: *const wchar_t, + argp: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_fwprintf( + _File: *mut FILE, + _Format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_wprintf(_Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vfwprintf( + _File: *mut FILE, + _Format: *const wchar_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vwprintf(_Format: *const wchar_t, _ArgList: va_list) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_snwprintf( + s: *mut wchar_t, + n: usize, + format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vsnwprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + arg4: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_swprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_vswprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + arg4: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}swscanf"] + pub fn __ms_swscanf( + _Src: *const wchar_t, + _Format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vswscanf"] + pub fn __ms_vswscanf( + _Src: *const wchar_t, + _Format: *const wchar_t, + arg1: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}wscanf"] + pub fn __ms_wscanf(_Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vwscanf"] + pub fn __ms_vwscanf(_Format: *const wchar_t, arg1: va_list) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}fwscanf"] + pub fn __ms_fwscanf(_File: *mut FILE, _Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vfwscanf"] + pub fn __ms_vfwscanf( + _File: *mut FILE, + _Format: *const wchar_t, + arg1: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __ms_fwprintf(_File: *mut FILE, _Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}wprintf"] + pub fn __ms_wprintf(_Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vfwprintf"] + pub fn __ms_vfwprintf( + _File: *mut FILE, + _Format: *const wchar_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vwprintf"] + pub fn __ms_vwprintf(_Format: *const wchar_t, _ArgList: va_list) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}swprintf"] + pub fn __ms_swprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vswprintf"] + pub fn __ms_vswprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + arg4: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}snwprintf"] + pub fn __ms_snwprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + #[link_name = "\u{1}vsnwprintf"] + pub fn __ms_vsnwprintf( + arg1: *mut wchar_t, + arg2: usize, + arg3: *const wchar_t, + arg4: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vswprintf( + options: ::std::os::raw::c_ulonglong, + str_: *mut wchar_t, + len: usize, + format: *const wchar_t, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfwprintf( + options: ::std::os::raw::c_ulonglong, + file: *mut FILE, + format: *const wchar_t, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vswscanf( + options: ::std::os::raw::c_ulonglong, + input: *const wchar_t, + length: usize, + format: *const wchar_t, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfwscanf( + options: ::std::os::raw::c_ulonglong, + file: *mut FILE, + format: *const wchar_t, + locale: _locale_t, + valist: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fwprintf(_File: *mut FILE, _Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wfsopen( + _Filename: *const wchar_t, + _Mode: *const wchar_t, + _ShFlag: ::std::os::raw::c_int, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn fgetwc(_File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn _fgetwchar() -> wint_t; +} +unsafe extern "C" { + pub fn fputwc(_Ch: wchar_t, _File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn _fputwchar(_Ch: wchar_t) -> wint_t; +} +unsafe extern "C" { + pub fn getwc(_File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn getwchar() -> wint_t; +} +unsafe extern "C" { + pub fn putwc(_Ch: wchar_t, _File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn putwchar(_Ch: wchar_t) -> wint_t; +} +unsafe extern "C" { + pub fn ungetwc(_Ch: wint_t, _File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn fgetws( + _Dst: *mut wchar_t, + _SizeInWords: ::std::os::raw::c_int, + _File: *mut FILE, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn fputws(_Str: *const wchar_t, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _getws(_String: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _putws(_Str: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _scwprintf(_Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _snwprintf( + _Dest: *mut wchar_t, + _Count: usize, + _Format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _vsnwprintf( + _Dest: *mut wchar_t, + _Count: usize, + _Format: *const wchar_t, + _Args: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _vscwprintf(_Format: *const wchar_t, _ArgList: va_list) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _swprintf(_Dest: *mut wchar_t, _Format: *const wchar_t, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _vswprintf( + _Dest: *mut wchar_t, + _Format: *const wchar_t, + _Args: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wtempnam(_Directory: *const wchar_t, _FilePrefix: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _snwscanf( + _Src: *const wchar_t, + _MaxCount: usize, + _Format: *const wchar_t, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wfdopen(_FileHandle: ::std::os::raw::c_int, _Mode: *const wchar_t) -> *mut FILE; +} +unsafe extern "C" { + pub fn _wfopen(_Filename: *const wchar_t, _Mode: *const wchar_t) -> *mut FILE; +} +unsafe extern "C" { + pub fn _wfreopen( + _Filename: *const wchar_t, + _Mode: *const wchar_t, + _OldFile: *mut FILE, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn _wperror(_ErrMsg: *const wchar_t); +} +unsafe extern "C" { + pub fn _wpopen(_Command: *const wchar_t, _Mode: *const wchar_t) -> *mut FILE; +} +unsafe extern "C" { + pub fn _wremove(_Filename: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wtmpnam(_Buffer: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _fgetwc_nolock(_File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn _fputwc_nolock(_Ch: wchar_t, _File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn _ungetwc_nolock(_Ch: wint_t, _File: *mut FILE) -> wint_t; +} +unsafe extern "C" { + pub fn _fgetc_nolock(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fputc_nolock(_Char: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _getc_nolock(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _putc_nolock(_Char: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _lock_file(_File: *mut FILE); +} +unsafe extern "C" { + pub fn _unlock_file(_File: *mut FILE); +} +unsafe extern "C" { + pub fn _fclose_nolock(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fflush_nolock(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fread_nolock( + _DstBuf: *mut ::std::os::raw::c_void, + _ElementSize: usize, + _Count: usize, + _File: *mut FILE, + ) -> usize; +} +unsafe extern "C" { + pub fn _fseek_nolock( + _File: *mut FILE, + _Offset: ::std::os::raw::c_long, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _ftell_nolock(_File: *mut FILE) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _fseeki64_nolock( + _File: *mut FILE, + _Offset: ::std::os::raw::c_longlong, + _Origin: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _ftelli64_nolock(_File: *mut FILE) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _fwrite_nolock( + _DstBuf: *const ::std::os::raw::c_void, + _Size: usize, + _Count: usize, + _File: *mut FILE, + ) -> usize; +} +unsafe extern "C" { + pub fn _ungetc_nolock(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tempnam( + _Directory: *const ::std::os::raw::c_char, + _FilePrefix: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fcloseall() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fdopen( + _FileHandle: ::std::os::raw::c_int, + _Format: *const ::std::os::raw::c_char, + ) -> *mut FILE; +} +unsafe extern "C" { + pub fn fgetchar() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fileno(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn flushall() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fputchar(_Ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn getw(_File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn putw(_Ch: ::std::os::raw::c_int, _File: *mut FILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn rmtmp() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_str_wide_utf8( + wptr: *const wchar_t, + mbptr: *mut *mut ::std::os::raw::c_char, + buflen: *mut usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_str_utf8_wide( + mbptr: *const ::std::os::raw::c_char, + wptr: *mut *mut wchar_t, + buflen: *mut usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __mingw_str_free(ptr: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn _wspawnl( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const wchar_t, + ... + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnle( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const wchar_t, + ... + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnlp( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const wchar_t, + ... + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnlpe( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const wchar_t, + ... + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnv( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const *const wchar_t, + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnve( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const *const wchar_t, + _Env: *const *const wchar_t, + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnvp( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const *const wchar_t, + ) -> isize; +} +unsafe extern "C" { + pub fn _wspawnvpe( + _Mode: ::std::os::raw::c_int, + _Filename: *const wchar_t, + _ArgList: *const *const wchar_t, + _Env: *const *const wchar_t, + ) -> isize; +} +unsafe extern "C" { + pub fn _spawnv( + _Mode: ::std::os::raw::c_int, + _Filename: *const ::std::os::raw::c_char, + _ArgList: *const *const ::std::os::raw::c_char, + ) -> isize; +} +unsafe extern "C" { + pub fn _spawnve( + _Mode: ::std::os::raw::c_int, + _Filename: *const ::std::os::raw::c_char, + _ArgList: *const *const ::std::os::raw::c_char, + _Env: *const *const ::std::os::raw::c_char, + ) -> isize; +} +unsafe extern "C" { + pub fn _spawnvp( + _Mode: ::std::os::raw::c_int, + _Filename: *const ::std::os::raw::c_char, + _ArgList: *const *const ::std::os::raw::c_char, + ) -> isize; +} +unsafe extern "C" { + pub fn _spawnvpe( + _Mode: ::std::os::raw::c_int, + _Filename: *const ::std::os::raw::c_char, + _ArgList: *const *const ::std::os::raw::c_char, + _Env: *const *const ::std::os::raw::c_char, + ) -> isize; +} +unsafe extern "C" { + pub fn clearerr_s(_File: *mut FILE) -> errno_t; +} +unsafe extern "C" { + pub fn fread_s( + _DstBuf: *mut ::std::os::raw::c_void, + _DstSize: usize, + _ElementSize: usize, + _Count: usize, + _File: *mut FILE, + ) -> usize; +} +unsafe extern "C" { + pub fn __stdio_common_vsprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _Str: *mut ::std::os::raw::c_char, + _Len: usize, + _Format: *const ::std::os::raw::c_char, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vsprintf_p( + _Options: ::std::os::raw::c_ulonglong, + _Str: *mut ::std::os::raw::c_char, + _Len: usize, + _Format: *const ::std::os::raw::c_char, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vsnprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _Str: *mut ::std::os::raw::c_char, + _Len: usize, + _MaxCount: usize, + _Format: *const ::std::os::raw::c_char, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _File: *mut FILE, + _Format: *const ::std::os::raw::c_char, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfprintf_p( + _Options: ::std::os::raw::c_ulonglong, + _File: *mut FILE, + _Format: *const ::std::os::raw::c_char, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fopen_s( + _File: *mut *mut FILE, + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn freopen_s( + _File: *mut *mut FILE, + _Filename: *const ::std::os::raw::c_char, + _Mode: *const ::std::os::raw::c_char, + _Stream: *mut FILE, + ) -> errno_t; +} +unsafe extern "C" { + pub fn gets_s(arg1: *mut ::std::os::raw::c_char, arg2: rsize_t) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn tmpfile_s(_File: *mut *mut FILE) -> errno_t; +} +unsafe extern "C" { + pub fn tmpnam_s(arg1: *mut ::std::os::raw::c_char, arg2: rsize_t) -> errno_t; +} +unsafe extern "C" { + pub fn _getws_s(_Str: *mut wchar_t, _SizeInWords: usize) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn __stdio_common_vswprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _Str: *mut wchar_t, + _Len: usize, + _Format: *const wchar_t, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vsnwprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _Str: *mut wchar_t, + _Len: usize, + _MaxCount: usize, + _Format: *const wchar_t, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __stdio_common_vfwprintf_s( + _Options: ::std::os::raw::c_ulonglong, + _File: *mut FILE, + _Format: *const wchar_t, + _Locale: _locale_t, + _ArgList: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wfopen_s( + _File: *mut *mut FILE, + _Filename: *const wchar_t, + _Mode: *const wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wfreopen_s( + _File: *mut *mut FILE, + _Filename: *const wchar_t, + _Mode: *const wchar_t, + _OldFile: *mut FILE, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wtmpnam_s(_DstBuf: *mut wchar_t, _SizeInWords: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _fread_nolock_s( + _DstBuf: *mut ::std::os::raw::c_void, + _DstSize: usize, + _ElementSize: usize, + _Count: usize, + _File: *mut FILE, + ) -> usize; +} +pub const htsLogLevel_HTS_LOG_OFF: htsLogLevel = 0; +pub const htsLogLevel_HTS_LOG_ERROR: htsLogLevel = 1; +pub const htsLogLevel_HTS_LOG_WARNING: htsLogLevel = 3; +pub const htsLogLevel_HTS_LOG_INFO: htsLogLevel = 4; +pub const htsLogLevel_HTS_LOG_DEBUG: htsLogLevel = 5; +pub const htsLogLevel_HTS_LOG_TRACE: htsLogLevel = 6; +pub type htsLogLevel = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn hts_set_log_level(level: htsLogLevel); +} +unsafe extern "C" { + pub fn hts_get_log_level() -> htsLogLevel; +} +unsafe extern "C" { + pub static mut hts_verbose: ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_log( + severity: htsLogLevel, + context: *const ::std::os::raw::c_char, + format: *const ::std::os::raw::c_char, + ... + ); +} +unsafe extern "C" { + pub fn _wdupenv_s( + _Buffer: *mut *mut wchar_t, + _BufferSizeInWords: *mut usize, + _VarName: *const wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _itow_s( + _Val: ::std::os::raw::c_int, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ltow_s( + _Val: ::std::os::raw::c_long, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ultow_s( + _Val: ::std::os::raw::c_ulong, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wgetenv_s( + _ReturnSize: *mut usize, + _DstBuf: *mut wchar_t, + _DstSizeInWords: usize, + _VarName: *const wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _i64tow_s( + _Val: ::std::os::raw::c_longlong, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ui64tow_s( + _Val: ::std::os::raw::c_ulonglong, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wmakepath_s( + _PathResult: *mut wchar_t, + _SizeInWords: usize, + _Drive: *const wchar_t, + _Dir: *const wchar_t, + _Filename: *const wchar_t, + _Ext: *const wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wputenv_s(_Name: *const wchar_t, _Value: *const wchar_t) -> errno_t; +} +unsafe extern "C" { + pub fn _wsearchenv_s( + _Filename: *const wchar_t, + _EnvVar: *const wchar_t, + _ResultPath: *mut wchar_t, + _SizeInWords: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wsplitpath_s( + _FullPath: *const wchar_t, + _Drive: *mut wchar_t, + _DriveSizeInWords: usize, + _Dir: *mut wchar_t, + _DirSizeInWords: usize, + _Filename: *mut wchar_t, + _FilenameSizeInWords: usize, + _Ext: *mut wchar_t, + _ExtSizeInWords: usize, + ) -> errno_t; +} +pub type _onexit_t = ::std::option::Option ::std::os::raw::c_int>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _div_t { + pub quot: ::std::os::raw::c_int, + pub rem: ::std::os::raw::c_int, +} +pub type div_t = _div_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ldiv_t { + pub quot: ::std::os::raw::c_long, + pub rem: ::std::os::raw::c_long, +} +pub type ldiv_t = _ldiv_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LDOUBLE { + pub ld: [::std::os::raw::c_uchar; 10usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _CRT_DOUBLE { + pub x: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _CRT_FLOAT { + pub f: f32, +} +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _LONGDOUBLE { + pub x: u128, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LDBL12 { + pub ld12: [::std::os::raw::c_uchar; 12usize], +} +unsafe extern "C" { + pub fn ___mb_cur_max_func() -> ::std::os::raw::c_int; +} +pub type _purecall_handler = ::std::option::Option; +unsafe extern "C" { + pub fn _set_purecall_handler(_Handler: _purecall_handler) -> _purecall_handler; +} +unsafe extern "C" { + pub fn _get_purecall_handler() -> _purecall_handler; +} +pub type _invalid_parameter_handler = ::std::option::Option< + unsafe extern "C" fn( + arg1: *const wchar_t, + arg2: *const wchar_t, + arg3: *const wchar_t, + arg4: ::std::os::raw::c_uint, + arg5: usize, + ), +>; +unsafe extern "C" { + pub fn _set_invalid_parameter_handler( + _Handler: _invalid_parameter_handler, + ) -> _invalid_parameter_handler; +} +unsafe extern "C" { + pub fn _get_invalid_parameter_handler() -> _invalid_parameter_handler; +} +unsafe extern "C" { + pub fn _errno() -> *mut ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_errno(_Value: ::std::os::raw::c_int) -> errno_t; +} +unsafe extern "C" { + pub fn _get_errno(_Value: *mut ::std::os::raw::c_int) -> errno_t; +} +unsafe extern "C" { + pub fn __doserrno() -> *mut ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _set_doserrno(_Value: ::std::os::raw::c_ulong) -> errno_t; +} +unsafe extern "C" { + pub fn _get_doserrno(_Value: *mut ::std::os::raw::c_ulong) -> errno_t; +} +unsafe extern "C" { + pub fn __sys_errlist() -> *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __sys_nerr() -> *mut ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __p___argv() -> *mut *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __p__fmode() -> *mut ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __p___argc() -> *mut ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __p___wargv() -> *mut *mut *mut wchar_t; +} +unsafe extern "C" { + pub fn __p__pgmptr() -> *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __p__wpgmptr() -> *mut *mut wchar_t; +} +unsafe extern "C" { + pub fn _get_pgmptr(_Value: *mut *mut ::std::os::raw::c_char) -> errno_t; +} +unsafe extern "C" { + pub fn _get_wpgmptr(_Value: *mut *mut wchar_t) -> errno_t; +} +unsafe extern "C" { + pub fn _set_fmode(_Mode: ::std::os::raw::c_int) -> errno_t; +} +unsafe extern "C" { + pub fn _get_fmode(_PMode: *mut ::std::os::raw::c_int) -> errno_t; +} +unsafe extern "C" { + pub fn __p__environ() -> *mut *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __p__wenviron() -> *mut *mut *mut wchar_t; +} +unsafe extern "C" { + pub fn __p__osplatform() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn __p__osver() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn __p__winver() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn __p__winmajor() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn __p__winminor() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn _get_osplatform(_Value: *mut ::std::os::raw::c_uint) -> errno_t; +} +unsafe extern "C" { + pub fn _get_osver(_Value: *mut ::std::os::raw::c_uint) -> errno_t; +} +unsafe extern "C" { + pub fn _get_winver(_Value: *mut ::std::os::raw::c_uint) -> errno_t; +} +unsafe extern "C" { + pub fn _get_winmajor(_Value: *mut ::std::os::raw::c_uint) -> errno_t; +} +unsafe extern "C" { + pub fn _get_winminor(_Value: *mut ::std::os::raw::c_uint) -> errno_t; +} +unsafe extern "C" { + pub fn exit(_Code: ::std::os::raw::c_int) -> !; +} +unsafe extern "C" { + pub fn _exit(_Code: ::std::os::raw::c_int) -> !; +} +unsafe extern "C" { + pub fn quick_exit(_Code: ::std::os::raw::c_int) -> !; +} +unsafe extern "C" { + pub fn _Exit(arg1: ::std::os::raw::c_int) -> !; +} +unsafe extern "C" { + pub fn abort() -> !; +} +unsafe extern "C" { + pub fn _set_abort_behavior( + _Flags: ::std::os::raw::c_uint, + _Mask: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn abs(_X: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn labs(_X: ::std::os::raw::c_long) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn atexit(arg1: ::std::option::Option) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn at_quick_exit( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn atof(_String: *const ::std::os::raw::c_char) -> f64; +} +unsafe extern "C" { + pub fn _atof_l(_String: *const ::std::os::raw::c_char, _Locale: _locale_t) -> f64; +} +unsafe extern "C" { + pub fn atoi(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atoi_l( + _Str: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn atol(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _atol_l( + _Str: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn bsearch( + _Key: *const ::std::os::raw::c_void, + _Base: *const ::std::os::raw::c_void, + _NumOfElements: usize, + _SizeOfElements: usize, + _PtFuncCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn qsort( + _Base: *mut ::std::os::raw::c_void, + _NumOfElements: usize, + _SizeOfElements: usize, + _PtFuncCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ); +} +unsafe extern "C" { + pub fn _byteswap_ushort(_Short: ::std::os::raw::c_ushort) -> ::std::os::raw::c_ushort; +} +unsafe extern "C" { + pub fn _byteswap_ulong(_Long: ::std::os::raw::c_ulong) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _byteswap_uint64(_Int64: ::std::os::raw::c_ulonglong) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn div(_Numerator: ::std::os::raw::c_int, _Denominator: ::std::os::raw::c_int) -> div_t; +} +unsafe extern "C" { + pub fn getenv(_VarName: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _itoa( + _Value: ::std::os::raw::c_int, + _Dest: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _i64toa( + _Val: ::std::os::raw::c_longlong, + _DstBuf: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _ui64toa( + _Val: ::std::os::raw::c_ulonglong, + _DstBuf: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _atoi64(_String: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _atoi64_l( + _String: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _strtoi64( + _String: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _strtoi64_l( + _String: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _strtoui64( + _String: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _strtoui64_l( + _String: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn ldiv(_Numerator: ::std::os::raw::c_long, _Denominator: ::std::os::raw::c_long) + -> ldiv_t; +} +unsafe extern "C" { + pub fn _ltoa( + _Value: ::std::os::raw::c_long, + _Dest: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn mblen(_Ch: *const ::std::os::raw::c_char, _MaxCount: usize) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _mblen_l( + _Ch: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _mbstrlen(_Str: *const ::std::os::raw::c_char) -> usize; +} +unsafe extern "C" { + pub fn _mbstrlen_l(_Str: *const ::std::os::raw::c_char, _Locale: _locale_t) -> usize; +} +unsafe extern "C" { + pub fn _mbstrnlen(_Str: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; +} +unsafe extern "C" { + pub fn _mbstrnlen_l( + _Str: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn mbtowc( + _DstCh: *mut wchar_t, + _SrcCh: *const ::std::os::raw::c_char, + _SrcSizeInBytes: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _mbtowc_l( + _DstCh: *mut wchar_t, + _SrcCh: *const ::std::os::raw::c_char, + _SrcSizeInBytes: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn mbstowcs( + _Dest: *mut wchar_t, + _Source: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn _mbstowcs_l( + _Dest: *mut wchar_t, + _Source: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn mkstemp(_TemplateName: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn mkdtemp(_TemplateName: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn rand() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_error_mode(_Mode: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn srand(_Seed: ::std::os::raw::c_uint); +} +unsafe extern "C" { + pub fn strtod( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + ) -> f64; +} +unsafe extern "C" { + pub fn strtof( + nptr: *const ::std::os::raw::c_char, + endptr: *mut *mut ::std::os::raw::c_char, + ) -> f32; +} +unsafe extern "C" { + pub fn __strtod( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> f64; +} +unsafe extern "C" { + pub fn __mingw_strtof( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> f32; +} +unsafe extern "C" { + pub fn __mingw_strtod( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> f64; +} +unsafe extern "C" { + pub fn __mingw_strtold( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> u128; +} +unsafe extern "C" { + pub fn _strtof_l( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> f32; +} +unsafe extern "C" { + pub fn _strtod_l( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> f64; +} +unsafe extern "C" { + pub fn strtol( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _strtol_l( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn strtoul( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _strtoul_l( + _Str: *const ::std::os::raw::c_char, + _EndPtr: *mut *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn system(_Command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _ultoa( + _Value: ::std::os::raw::c_ulong, + _Dest: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn wctomb(_MbCh: *mut ::std::os::raw::c_char, _WCh: wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wctomb_l( + _MbCh: *mut ::std::os::raw::c_char, + _WCh: wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcstombs( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const wchar_t, + _MaxCount: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn _wcstombs_l( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn calloc( + _NumOfElements: ::std::os::raw::c_ulonglong, + _SizeOfElements: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn free(_Memory: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn malloc(_Size: ::std::os::raw::c_ulonglong) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn realloc( + _Memory: *mut ::std::os::raw::c_void, + _NewSize: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_free(_Memory: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn _aligned_malloc(_Size: usize, _Alignment: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_offset_malloc( + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_realloc( + _Memory: *mut ::std::os::raw::c_void, + _Size: usize, + _Alignment: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_offset_realloc( + _Memory: *mut ::std::os::raw::c_void, + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _recalloc( + _Memory: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_recalloc( + _Memory: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + _Alignment: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_offset_recalloc( + _Memory: *mut ::std::os::raw::c_void, + _Count: usize, + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _aligned_msize( + _Memory: *mut ::std::os::raw::c_void, + _Alignment: usize, + _Offset: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn _itow( + _Value: ::std::os::raw::c_int, + _Dest: *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _ltow( + _Value: ::std::os::raw::c_long, + _Dest: *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _ultow( + _Value: ::std::os::raw::c_ulong, + _Dest: *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn __mingw_wcstod(_Str: *const wchar_t, _EndPtr: *mut *mut wchar_t) -> f64; +} +unsafe extern "C" { + pub fn __mingw_wcstof(nptr: *const wchar_t, endptr: *mut *mut wchar_t) -> f32; +} +unsafe extern "C" { + pub fn __mingw_wcstold(arg1: *const wchar_t, arg2: *mut *mut wchar_t) -> u128; +} +unsafe extern "C" { + pub fn wcstod(_Str: *const wchar_t, _EndPtr: *mut *mut wchar_t) -> f64; +} +unsafe extern "C" { + pub fn wcstof(nptr: *const wchar_t, endptr: *mut *mut wchar_t) -> f32; +} +unsafe extern "C" { + pub fn wcstold(arg1: *const wchar_t, arg2: *mut *mut wchar_t) -> u128; +} +unsafe extern "C" { + pub fn _wcstod_l(_Str: *const wchar_t, _EndPtr: *mut *mut wchar_t, _Locale: _locale_t) -> f64; +} +unsafe extern "C" { + pub fn _wcstof_l(_Str: *const wchar_t, _EndPtr: *mut *mut wchar_t, _Locale: _locale_t) -> f32; +} +unsafe extern "C" { + pub fn wcstol( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _wcstol_l( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn wcstoul( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _wcstoul_l( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _wgetenv(_VarName: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wsystem(_Command: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wtof(_Str: *const wchar_t) -> f64; +} +unsafe extern "C" { + pub fn _wtof_l(_Str: *const wchar_t, _Locale: _locale_t) -> f64; +} +unsafe extern "C" { + pub fn _wtoi(_Str: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wtoi_l(_Str: *const wchar_t, _Locale: _locale_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wtol(_Str: *const wchar_t) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _wtol_l(_Str: *const wchar_t, _Locale: _locale_t) -> ::std::os::raw::c_long; +} +unsafe extern "C" { + pub fn _i64tow( + _Val: ::std::os::raw::c_longlong, + _DstBuf: *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _ui64tow( + _Val: ::std::os::raw::c_ulonglong, + _DstBuf: *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wtoi64(_Str: *const wchar_t) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _wtoi64_l(_Str: *const wchar_t, _Locale: _locale_t) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _wcstoi64( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _wcstoi64_l( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn _wcstoui64( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _wcstoui64_l( + _Str: *const wchar_t, + _EndPtr: *mut *mut wchar_t, + _Radix: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _putenv(_EnvString: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wputenv(_EnvString: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _fullpath( + _FullPath: *mut ::std::os::raw::c_char, + _Path: *const ::std::os::raw::c_char, + _SizeInBytes: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _ecvt( + _Val: f64, + _NumOfDigits: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _fcvt( + _Val: f64, + _NumOfDec: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _gcvt( + _Val: f64, + _NumOfDigits: ::std::os::raw::c_int, + _DstBuf: *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _atodbl( + _Result: *mut _CRT_DOUBLE, + _Str: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atoldbl( + _Result: *mut _LDOUBLE, + _Str: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atoflt( + _Result: *mut _CRT_FLOAT, + _Str: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atodbl_l( + _Result: *mut _CRT_DOUBLE, + _Str: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atoldbl_l( + _Result: *mut _LDOUBLE, + _Str: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _atoflt_l( + _Result: *mut _CRT_FLOAT, + _Str: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _lrotl( + arg1: ::std::os::raw::c_ulong, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _lrotr( + arg1: ::std::os::raw::c_ulong, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _makepath( + _Path: *mut ::std::os::raw::c_char, + _Drive: *const ::std::os::raw::c_char, + _Dir: *const ::std::os::raw::c_char, + _Filename: *const ::std::os::raw::c_char, + _Ext: *const ::std::os::raw::c_char, + ); +} +unsafe extern "C" { + pub fn _onexit(_Func: _onexit_t) -> _onexit_t; +} +unsafe extern "C" { + pub fn _rotl64( + _Val: ::std::os::raw::c_ulonglong, + _Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _rotr64( + Value: ::std::os::raw::c_ulonglong, + Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _rotr( + _Val: ::std::os::raw::c_uint, + _Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn _rotl( + _Val: ::std::os::raw::c_uint, + _Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn _searchenv( + _Filename: *const ::std::os::raw::c_char, + _EnvVar: *const ::std::os::raw::c_char, + _ResultPath: *mut ::std::os::raw::c_char, + ); +} +unsafe extern "C" { + pub fn _splitpath( + _FullPath: *const ::std::os::raw::c_char, + _Drive: *mut ::std::os::raw::c_char, + _Dir: *mut ::std::os::raw::c_char, + _Filename: *mut ::std::os::raw::c_char, + _Ext: *mut ::std::os::raw::c_char, + ); +} +unsafe extern "C" { + pub fn _swab( + _Buf1: *mut ::std::os::raw::c_char, + _Buf2: *mut ::std::os::raw::c_char, + _SizeInBytes: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + pub fn _wfullpath( + _FullPath: *mut wchar_t, + _Path: *const wchar_t, + _SizeInWords: usize, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wmakepath( + _ResultPath: *mut wchar_t, + _Drive: *const wchar_t, + _Dir: *const wchar_t, + _Filename: *const wchar_t, + _Ext: *const wchar_t, + ); +} +unsafe extern "C" { + pub fn _wsearchenv( + _Filename: *const wchar_t, + _EnvVar: *const wchar_t, + _ResultPath: *mut wchar_t, + ); +} +unsafe extern "C" { + pub fn _wsplitpath( + _FullPath: *const wchar_t, + _Drive: *mut wchar_t, + _Dir: *mut wchar_t, + _Filename: *mut wchar_t, + _Ext: *mut wchar_t, + ); +} +unsafe extern "C" { + pub fn _beep(_Frequency: ::std::os::raw::c_uint, _Duration: ::std::os::raw::c_uint); +} +unsafe extern "C" { + pub fn _seterrormode(_Mode: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn _sleep(_Duration: ::std::os::raw::c_ulong); +} +unsafe extern "C" { + pub fn ecvt( + _Val: f64, + _NumOfDigits: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fcvt( + _Val: f64, + _NumOfDec: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn gcvt( + _Val: f64, + _NumOfDigits: ::std::os::raw::c_int, + _DstBuf: *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn itoa( + _Val: ::std::os::raw::c_int, + _DstBuf: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn ltoa( + _Val: ::std::os::raw::c_long, + _DstBuf: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn putenv(_EnvString: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn swab( + _Buf1: *mut ::std::os::raw::c_char, + _Buf2: *mut ::std::os::raw::c_char, + _SizeInBytes: ::std::os::raw::c_int, + ); +} +unsafe extern "C" { + pub fn ultoa( + _Val: ::std::os::raw::c_ulong, + _Dstbuf: *mut ::std::os::raw::c_char, + _Radix: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn onexit(_Func: _onexit_t) -> _onexit_t; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct lldiv_t { + pub quot: ::std::os::raw::c_longlong, + pub rem: ::std::os::raw::c_longlong, +} +unsafe extern "C" { + pub fn lldiv(arg1: ::std::os::raw::c_longlong, arg2: ::std::os::raw::c_longlong) -> lldiv_t; +} +unsafe extern "C" { + pub fn llabs(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn strtoll( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn strtoull( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn atoll(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn wtoll(arg1: *const wchar_t) -> ::std::os::raw::c_longlong; +} +unsafe extern "C" { + pub fn lltoa( + arg1: ::std::os::raw::c_longlong, + arg2: *mut ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn ulltoa( + arg1: ::std::os::raw::c_ulonglong, + arg2: *mut ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn lltow( + arg1: ::std::os::raw::c_longlong, + arg2: *mut wchar_t, + arg3: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn ulltow( + arg1: ::std::os::raw::c_ulonglong, + arg2: *mut wchar_t, + arg3: ::std::os::raw::c_int, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _dupenv_s( + _PBuffer: *mut *mut ::std::os::raw::c_char, + _PBufferSizeInBytes: *mut usize, + _VarName: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn bsearch_s( + _Key: *const ::std::os::raw::c_void, + _Base: *const ::std::os::raw::c_void, + _NumOfElements: rsize_t, + _SizeOfElements: rsize_t, + _PtFuncCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + _Context: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn getenv_s( + _ReturnSize: *mut usize, + _DstBuf: *mut ::std::os::raw::c_char, + _DstSize: rsize_t, + _VarName: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _itoa_s( + _Value: ::std::os::raw::c_int, + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _i64toa_s( + _Val: ::std::os::raw::c_longlong, + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ui64toa_s( + _Val: ::std::os::raw::c_ulonglong, + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ltoa_s( + _Val: ::std::os::raw::c_long, + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn mbstowcs_s( + _PtNumOfCharConverted: *mut usize, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _SrcBuf: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _mbstowcs_s_l( + _PtNumOfCharConverted: *mut usize, + _DstBuf: *mut wchar_t, + _SizeInWords: usize, + _SrcBuf: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ultoa_s( + _Val: ::std::os::raw::c_ulong, + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Radix: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn wctomb_s( + _SizeConverted: *mut ::std::os::raw::c_int, + _MbCh: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _WCh: wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wctomb_s_l( + _SizeConverted: *mut ::std::os::raw::c_int, + _MbCh: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _WCh: wchar_t, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn wcstombs_s( + _PtNumOfCharConverted: *mut usize, + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInBytes: usize, + _Src: *const wchar_t, + _MaxCountInBytes: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcstombs_s_l( + _PtNumOfCharConverted: *mut usize, + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInBytes: usize, + _Src: *const wchar_t, + _MaxCountInBytes: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _ecvt_s( + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Val: f64, + _NumOfDights: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _fcvt_s( + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Val: f64, + _NumOfDec: ::std::os::raw::c_int, + _PtDec: *mut ::std::os::raw::c_int, + _PtSign: *mut ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _gcvt_s( + _DstBuf: *mut ::std::os::raw::c_char, + _Size: usize, + _Val: f64, + _NumOfDigits: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _makepath_s( + _PathResult: *mut ::std::os::raw::c_char, + _Size: usize, + _Drive: *const ::std::os::raw::c_char, + _Dir: *const ::std::os::raw::c_char, + _Filename: *const ::std::os::raw::c_char, + _Ext: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _putenv_s( + _Name: *const ::std::os::raw::c_char, + _Value: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _searchenv_s( + _Filename: *const ::std::os::raw::c_char, + _EnvVar: *const ::std::os::raw::c_char, + _ResultPath: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _splitpath_s( + _FullPath: *const ::std::os::raw::c_char, + _Drive: *mut ::std::os::raw::c_char, + _DriveSize: usize, + _Dir: *mut ::std::os::raw::c_char, + _DirSize: usize, + _Filename: *mut ::std::os::raw::c_char, + _FilenameSize: usize, + _Ext: *mut ::std::os::raw::c_char, + _ExtSize: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn qsort_s( + _Base: *mut ::std::os::raw::c_void, + _NumOfElements: usize, + _SizeOfElements: usize, + _PtFuncCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + _Context: *mut ::std::os::raw::c_void, + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _heapinfo { + pub _pentry: *mut ::std::os::raw::c_int, + pub _size: usize, + pub _useflag: ::std::os::raw::c_int, +} +pub type _HEAPINFO = _heapinfo; +unsafe extern "C" { + pub fn __p__amblksiz() -> *mut ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn __mingw_aligned_malloc(_Size: usize, _Alignment: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn __mingw_aligned_free(_Memory: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn __mingw_aligned_offset_realloc( + _Memory: *mut ::std::os::raw::c_void, + _Size: usize, + _Alignment: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn __mingw_aligned_offset_malloc( + arg1: usize, + arg2: usize, + arg3: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn __mingw_aligned_realloc( + _Memory: *mut ::std::os::raw::c_void, + _Size: usize, + _Offset: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn __mingw_aligned_msize( + memblock: *mut ::std::os::raw::c_void, + alignment: usize, + offset: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn _resetstkoflw() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_malloc_crt_max_wait(_NewValue: ::std::os::raw::c_ulong) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn _expand( + _Memory: *mut ::std::os::raw::c_void, + _NewSize: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _msize(_Memory: *mut ::std::os::raw::c_void) -> usize; +} +unsafe extern "C" { + pub fn _get_sbh_threshold() -> usize; +} +unsafe extern "C" { + pub fn _set_sbh_threshold(_NewValue: usize) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _set_amblksiz(_Value: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _get_amblksiz(_Value: *mut usize) -> errno_t; +} +unsafe extern "C" { + pub fn _heapadd(_Memory: *mut ::std::os::raw::c_void, _Size: usize) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _heapchk() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _heapmin() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _heapset(_Fill: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _heapwalk(_EntryInfo: *mut _HEAPINFO) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _heapused(_Used: *mut usize, _Commit: *mut usize) -> usize; +} +unsafe extern "C" { + pub fn _get_heap_handle() -> isize; +} +unsafe extern "C" { + pub fn _memccpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memchr( + _Buf: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _memicmp_l( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memcmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memcpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memcpy_s( + _dest: *mut ::std::os::raw::c_void, + _numberOfElements: usize, + _src: *const ::std::os::raw::c_void, + _count: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn mempcpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset( + _Dst: *mut ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memccpy( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Val: ::std::os::raw::c_int, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memicmp( + _Buf1: *const ::std::os::raw::c_void, + _Buf2: *const ::std::os::raw::c_void, + _Size: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strset( + _Str: *mut ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strset_l( + _Str: *mut ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcpy( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcat( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strlen(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn strnlen(_Str: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; +} +unsafe extern "C" { + pub fn memmove( + _Dst: *mut ::std::os::raw::c_void, + _Src: *const ::std::os::raw::c_void, + _Size: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn _strdup(_Src: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strchr( + _Str: *const ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _stricmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strcmpi( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _stricmp_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcoll( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strcoll_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _stricoll( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _stricoll_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strncoll( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strncoll_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strnicoll( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strnicoll_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcspn( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _strerror(_ErrMsg: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlwr_l( + _String: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncat( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _Count: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strnicmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strnicmp_l( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncpy( + _Dest: *mut ::std::os::raw::c_char, + _Source: *const ::std::os::raw::c_char, + _Count: ::std::os::raw::c_ulonglong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strnset( + _Str: *mut ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strnset_l( + str_: *mut ::std::os::raw::c_char, + c: ::std::os::raw::c_int, + count: usize, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strpbrk( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strrchr( + _Str: *const ::std::os::raw::c_char, + _Ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strrev(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strspn( + _Str: *const ::std::os::raw::c_char, + _Control: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn strstr( + _Str: *const ::std::os::raw::c_char, + _SubStr: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok( + _Str: *mut ::std::os::raw::c_char, + _Delim: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok_r( + _Str: *mut ::std::os::raw::c_char, + _Delim: *const ::std::os::raw::c_char, + __last: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strupr_l( + _String: *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strxfrm( + _Dst: *mut ::std::os::raw::c_char, + _Src: *const ::std::os::raw::c_char, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn _strxfrm_l( + _Dst: *mut ::std::os::raw::c_char, + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn strdup(_Src: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcmpi( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stricmp( + _Str1: *const ::std::os::raw::c_char, + _Str2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strlwr(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strnicmp( + _Str1: *const ::std::os::raw::c_char, + _Str: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcasecmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strnset( + _Str: *mut ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strrev(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strset( + _Str: *mut ::std::os::raw::c_char, + _Val: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strupr(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _wcsdup(_Str: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcscat(_Dest: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcschr( + _Str: *const ::std::os::raw::c_ushort, + _Ch: ::std::os::raw::c_ushort, + ) -> *mut ::std::os::raw::c_ushort; +} +unsafe extern "C" { + pub fn wcscmp( + _Str1: *const ::std::os::raw::c_ushort, + _Str2: *const ::std::os::raw::c_ushort, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcscpy(_Dest: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcscspn(_Str: *const wchar_t, _Control: *const wchar_t) -> usize; +} +unsafe extern "C" { + pub fn wcslen(_Str: *const ::std::os::raw::c_ushort) -> ::std::os::raw::c_ulonglong; +} +unsafe extern "C" { + pub fn wcsnlen(_Src: *const wchar_t, _MaxCount: usize) -> usize; +} +unsafe extern "C" { + pub fn wcsncat(_Dest: *mut wchar_t, _Source: *const wchar_t, _Count: usize) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsncmp( + _Str1: *const ::std::os::raw::c_ushort, + _Str2: *const ::std::os::raw::c_ushort, + _MaxCount: ::std::os::raw::c_ulonglong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcsncpy(_Dest: *mut wchar_t, _Source: *const wchar_t, _Count: usize) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsncpy_l( + _Dest: *mut wchar_t, + _Source: *const wchar_t, + _Count: usize, + _Locale: _locale_t, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcspbrk(_Str: *const wchar_t, _Control: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsrchr(_Str: *const wchar_t, _Ch: wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsspn(_Str: *const wchar_t, _Control: *const wchar_t) -> usize; +} +unsafe extern "C" { + pub fn wcsstr(_Str: *const wchar_t, _SubStr: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcstok( + _Str: *mut wchar_t, + _Delim: *const wchar_t, + _Ptr: *mut *mut wchar_t, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcstok(_Str: *mut wchar_t, _Delim: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcserror(_ErrNum: ::std::os::raw::c_int) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn __wcserror(_Str: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsicmp(_Str1: *const wchar_t, _Str2: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsicmp_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsnicmp( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsnicmp_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsnset(_Str: *mut wchar_t, _Val: wchar_t, _MaxCount: usize) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsrev(_Str: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsset(_Str: *mut wchar_t, _Val: wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcslwr(_String: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcslwr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsupr(_String: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsupr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsxfrm(_Dst: *mut wchar_t, _Src: *const wchar_t, _MaxCount: usize) -> usize; +} +unsafe extern "C" { + pub fn _wcsxfrm_l( + _Dst: *mut wchar_t, + _Src: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn wcscoll(_Str1: *const wchar_t, _Str2: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcscoll_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsicoll(_Str1: *const wchar_t, _Str2: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsicoll_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsncoll( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsncoll_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsnicoll( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _wcsnicoll_l( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcsdup(_Str: *const wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsicmp(_Str1: *const wchar_t, _Str2: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcsnicmp( + _Str1: *const wchar_t, + _Str2: *const wchar_t, + _MaxCount: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn wcsnset(_Str: *mut wchar_t, _Val: wchar_t, _MaxCount: usize) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsrev(_Str: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsset(_Str: *mut wchar_t, _Val: wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcslwr(_Str: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsupr(_Str: *mut wchar_t) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn wcsicoll(_Str1: *const wchar_t, _Str2: *const wchar_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn _strset_s( + _Dst: *mut ::std::os::raw::c_char, + _DstSize: usize, + _Value: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strerror_s( + _Buf: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _ErrMsg: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn strerror_s( + _Buf: *mut ::std::os::raw::c_char, + _SizeInBytes: usize, + _ErrNum: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strlwr_s(_Str: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _strlwr_s_l( + _Str: *mut ::std::os::raw::c_char, + _Size: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strnset_s( + _Str: *mut ::std::os::raw::c_char, + _Size: usize, + _Val: ::std::os::raw::c_int, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strupr_s(_Str: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _strupr_s_l( + _Str: *mut ::std::os::raw::c_char, + _Size: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn strncat_s( + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInChars: usize, + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strncat_s_l( + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInChars: usize, + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn strcpy_s( + _Dst: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Src: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn strncpy_s( + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInChars: usize, + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _strncpy_s_l( + _Dst: *mut ::std::os::raw::c_char, + _DstSizeInChars: usize, + _Src: *const ::std::os::raw::c_char, + _MaxCount: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn strtok_s( + _Str: *mut ::std::os::raw::c_char, + _Delim: *const ::std::os::raw::c_char, + _Context: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn _strtok_s_l( + _Str: *mut ::std::os::raw::c_char, + _Delim: *const ::std::os::raw::c_char, + _Context: *mut *mut ::std::os::raw::c_char, + _Locale: _locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcat_s( + _Dst: *mut ::std::os::raw::c_char, + _SizeInBytes: rsize_t, + _Src: *const ::std::os::raw::c_char, + ) -> errno_t; +} +unsafe extern "C" { + pub fn memmove_s( + _dest: *mut ::std::os::raw::c_void, + _numberOfElements: usize, + _src: *const ::std::os::raw::c_void, + _count: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn wcstok_s( + _Str: *mut wchar_t, + _Delim: *const wchar_t, + _Context: *mut *mut wchar_t, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcserror_s( + _Buf: *mut wchar_t, + _SizeInWords: usize, + _ErrNum: ::std::os::raw::c_int, + ) -> errno_t; +} +unsafe extern "C" { + pub fn __wcserror_s( + _Buffer: *mut wchar_t, + _SizeInWords: usize, + _ErrMsg: *const wchar_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsnset_s( + _Dst: *mut wchar_t, + _DstSizeInWords: usize, + _Val: wchar_t, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsset_s(_Str: *mut wchar_t, _SizeInWords: usize, _Val: wchar_t) -> errno_t; +} +unsafe extern "C" { + pub fn _wcslwr_s(_Str: *mut wchar_t, _SizeInWords: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _wcslwr_s_l(_Str: *mut wchar_t, _SizeInWords: usize, _Locale: _locale_t) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsupr_s(_Str: *mut wchar_t, _Size: usize) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsupr_s_l(_Str: *mut wchar_t, _Size: usize, _Locale: _locale_t) -> errno_t; +} +unsafe extern "C" { + pub fn wcscpy_s(_Dst: *mut wchar_t, _SizeInWords: rsize_t, _Src: *const wchar_t) -> errno_t; +} +unsafe extern "C" { + pub fn wcscat_s(_Dst: *mut wchar_t, _SizeInWords: rsize_t, _Src: *const wchar_t) -> errno_t; +} +unsafe extern "C" { + pub fn wcsncat_s( + _Dst: *mut wchar_t, + _DstSizeInChars: usize, + _Src: *const wchar_t, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsncat_s_l( + _Dst: *mut wchar_t, + _DstSizeInChars: usize, + _Src: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn wcsncpy_s( + _Dst: *mut wchar_t, + _DstSizeInChars: usize, + _Src: *const wchar_t, + _MaxCount: usize, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsncpy_s_l( + _Dst: *mut wchar_t, + _DstSizeInChars: usize, + _Src: *const wchar_t, + _MaxCount: usize, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcstok_s_l( + _Str: *mut wchar_t, + _Delim: *const wchar_t, + _Context: *mut *mut wchar_t, + _Locale: _locale_t, + ) -> *mut wchar_t; +} +unsafe extern "C" { + pub fn _wcsset_s_l( + _Str: *mut wchar_t, + _SizeInChars: usize, + _Val: wchar_t, + _Locale: _locale_t, + ) -> errno_t; +} +unsafe extern "C" { + pub fn _wcsnset_s_l( + _Str: *mut wchar_t, + _SizeInChars: usize, + _Val: wchar_t, + _Count: usize, + _Locale: _locale_t, + ) -> errno_t; +} +pub type _ino_t = ::std::os::raw::c_ushort; +pub type ino_t = ::std::os::raw::c_ushort; +pub type _dev_t = ::std::os::raw::c_uint; +pub type dev_t = ::std::os::raw::c_uint; +pub type _pid_t = ::std::os::raw::c_longlong; +pub type pid_t = _pid_t; +pub type _mode_t = ::std::os::raw::c_ushort; +pub type mode_t = _mode_t; +pub type useconds_t = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct timespec { + pub tv_sec: time_t, + pub tv_nsec: ::std::os::raw::c_long, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct itimerspec { + pub it_interval: timespec, + pub it_value: timespec, +} +pub type _sigset_t = ::std::os::raw::c_ulonglong; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct kstring_t { + pub l: usize, + pub m: usize, + pub s: *mut ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ks_tokaux_t { + pub tab: [u64; 4usize], + pub sep: ::std::os::raw::c_int, + pub finished: ::std::os::raw::c_int, + pub p: *const ::std::os::raw::c_char, +} +unsafe extern "C" { + pub fn kvsprintf( + s: *mut kstring_t, + fmt: *const ::std::os::raw::c_char, + ap: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ksprintf( + s: *mut kstring_t, + fmt: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn kputd(d: f64, s: *mut kstring_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ksplit_core( + s: *mut ::std::os::raw::c_char, + delimiter: ::std::os::raw::c_int, + _max: *mut ::std::os::raw::c_int, + _offsets: *mut *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn kstrstr( + str_: *const ::std::os::raw::c_char, + pat: *const ::std::os::raw::c_char, + _prep: *mut *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn kstrnstr( + str_: *const ::std::os::raw::c_char, + pat: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + _prep: *mut *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn kmemmem( + _str: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + _pat: *const ::std::os::raw::c_void, + m: ::std::os::raw::c_int, + _prep: *mut *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn kstrtok( + str_: *const ::std::os::raw::c_char, + sep: *const ::std::os::raw::c_char, + aux: *mut ks_tokaux_t, + ) -> *mut ::std::os::raw::c_char; +} +pub type kgets_func = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_char, +>; +unsafe extern "C" { + pub fn kgetline( + s: *mut kstring_t, + fgets_fn: kgets_func, + fp: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +pub type kgets_func2 = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_char, + arg2: usize, + arg3: *mut ::std::os::raw::c_void, + ) -> isize, +>; +unsafe extern "C" { + pub fn kgetline2( + s: *mut kstring_t, + fgets_fn: kgets_func2, + fp: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_fd { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_tpool { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn hts_resize_array_( + arg1: usize, + arg2: usize, + arg3: usize, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_void, + arg6: ::std::os::raw::c_int, + arg7: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_lib_shutdown(); +} +unsafe extern "C" { + pub fn hts_free(ptr: *mut ::std::os::raw::c_void); +} +pub const htsFormatCategory_unknown_category: htsFormatCategory = 0; +pub const htsFormatCategory_sequence_data: htsFormatCategory = 1; +pub const htsFormatCategory_variant_data: htsFormatCategory = 2; +pub const htsFormatCategory_index_file: htsFormatCategory = 3; +pub const htsFormatCategory_region_list: htsFormatCategory = 4; +pub const htsFormatCategory_category_maximum: htsFormatCategory = 32767; +pub type htsFormatCategory = ::std::os::raw::c_uint; +pub const htsExactFormat_unknown_format: htsExactFormat = 0; +pub const htsExactFormat_binary_format: htsExactFormat = 1; +pub const htsExactFormat_text_format: htsExactFormat = 2; +pub const htsExactFormat_sam: htsExactFormat = 3; +pub const htsExactFormat_bam: htsExactFormat = 4; +pub const htsExactFormat_bai: htsExactFormat = 5; +pub const htsExactFormat_cram: htsExactFormat = 6; +pub const htsExactFormat_crai: htsExactFormat = 7; +pub const htsExactFormat_vcf: htsExactFormat = 8; +pub const htsExactFormat_bcf: htsExactFormat = 9; +pub const htsExactFormat_csi: htsExactFormat = 10; +pub const htsExactFormat_gzi: htsExactFormat = 11; +pub const htsExactFormat_tbi: htsExactFormat = 12; +pub const htsExactFormat_bed: htsExactFormat = 13; +pub const htsExactFormat_htsget: htsExactFormat = 14; +pub const htsExactFormat_json: htsExactFormat = 14; +pub const htsExactFormat_empty_format: htsExactFormat = 15; +pub const htsExactFormat_fasta_format: htsExactFormat = 16; +pub const htsExactFormat_fastq_format: htsExactFormat = 17; +pub const htsExactFormat_fai_format: htsExactFormat = 18; +pub const htsExactFormat_fqi_format: htsExactFormat = 19; +pub const htsExactFormat_hts_crypt4gh_format: htsExactFormat = 20; +pub const htsExactFormat_d4_format: htsExactFormat = 21; +pub const htsExactFormat_format_maximum: htsExactFormat = 32767; +pub type htsExactFormat = ::std::os::raw::c_uint; +pub const htsCompression_no_compression: htsCompression = 0; +pub const htsCompression_gzip: htsCompression = 1; +pub const htsCompression_bgzf: htsCompression = 2; +pub const htsCompression_custom: htsCompression = 3; +pub const htsCompression_bzip2_compression: htsCompression = 4; +pub const htsCompression_razf_compression: htsCompression = 5; +pub const htsCompression_xz_compression: htsCompression = 6; +pub const htsCompression_zstd_compression: htsCompression = 7; +pub const htsCompression_compression_maximum: htsCompression = 32767; +pub type htsCompression = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct htsFormat { + pub category: htsFormatCategory, + pub format: htsExactFormat, + pub version: htsFormat__bindgen_ty_1, + pub compression: htsCompression, + pub compression_level: ::std::os::raw::c_short, + pub specific: *mut ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct htsFormat__bindgen_ty_1 { + pub major: ::std::os::raw::c_short, + pub minor: ::std::os::raw::c_short, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_idx_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_filter_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct htsFile { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub lineno: i64, + pub line: kstring_t, + pub fn_: *mut ::std::os::raw::c_char, + pub fn_aux: *mut ::std::os::raw::c_char, + pub fp: htsFile__bindgen_ty_1, + pub state: *mut ::std::os::raw::c_void, + pub format: htsFormat, + pub idx: *mut hts_idx_t, + pub fnidx: *const ::std::os::raw::c_char, + pub bam_header: *mut sam_hdr_t, + pub filter: *mut hts_filter_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union htsFile__bindgen_ty_1 { + pub bgzf: *mut BGZF, + pub cram: *mut cram_fd, + pub hfile: *mut hFILE, +} +impl htsFile { + #[inline] + pub fn is_bin(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_bin(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_bin_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_bin_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_write(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_write(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_write_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_write_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_be(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_be(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_be_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_be_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_cram(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_cram(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_cram_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_cram_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_bgzf(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_bgzf(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_bgzf_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_bgzf_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn dummy(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_dummy(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn dummy_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dummy_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + is_bin: u32, + is_write: u32, + is_be: u32, + is_cram: u32, + is_bgzf: u32, + dummy: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_bin: u32 = unsafe { ::std::mem::transmute(is_bin) }; + is_bin as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_write: u32 = unsafe { ::std::mem::transmute(is_write) }; + is_write as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let is_be: u32 = unsafe { ::std::mem::transmute(is_be) }; + is_be as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is_cram: u32 = unsafe { ::std::mem::transmute(is_cram) }; + is_cram as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is_bgzf: u32 = unsafe { ::std::mem::transmute(is_bgzf) }; + is_bgzf as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let dummy: u32 = unsafe { ::std::mem::transmute(dummy) }; + dummy as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct htsThreadPool { + pub pool: *mut hts_tpool, + pub qsize: ::std::os::raw::c_int, +} +pub const sam_fields_SAM_QNAME: sam_fields = 1; +pub const sam_fields_SAM_FLAG: sam_fields = 2; +pub const sam_fields_SAM_RNAME: sam_fields = 4; +pub const sam_fields_SAM_POS: sam_fields = 8; +pub const sam_fields_SAM_MAPQ: sam_fields = 16; +pub const sam_fields_SAM_CIGAR: sam_fields = 32; +pub const sam_fields_SAM_RNEXT: sam_fields = 64; +pub const sam_fields_SAM_PNEXT: sam_fields = 128; +pub const sam_fields_SAM_TLEN: sam_fields = 256; +pub const sam_fields_SAM_SEQ: sam_fields = 512; +pub const sam_fields_SAM_QUAL: sam_fields = 1024; +pub const sam_fields_SAM_AUX: sam_fields = 2048; +pub const sam_fields_SAM_RGAUX: sam_fields = 4096; +pub type sam_fields = ::std::os::raw::c_uint; +pub const hts_fmt_option_CRAM_OPT_DECODE_MD: hts_fmt_option = 0; +pub const hts_fmt_option_CRAM_OPT_PREFIX: hts_fmt_option = 1; +pub const hts_fmt_option_CRAM_OPT_VERBOSITY: hts_fmt_option = 2; +pub const hts_fmt_option_CRAM_OPT_SEQS_PER_SLICE: hts_fmt_option = 3; +pub const hts_fmt_option_CRAM_OPT_SLICES_PER_CONTAINER: hts_fmt_option = 4; +pub const hts_fmt_option_CRAM_OPT_RANGE: hts_fmt_option = 5; +pub const hts_fmt_option_CRAM_OPT_VERSION: hts_fmt_option = 6; +pub const hts_fmt_option_CRAM_OPT_EMBED_REF: hts_fmt_option = 7; +pub const hts_fmt_option_CRAM_OPT_IGNORE_MD5: hts_fmt_option = 8; +pub const hts_fmt_option_CRAM_OPT_REFERENCE: hts_fmt_option = 9; +pub const hts_fmt_option_CRAM_OPT_MULTI_SEQ_PER_SLICE: hts_fmt_option = 10; +pub const hts_fmt_option_CRAM_OPT_NO_REF: hts_fmt_option = 11; +pub const hts_fmt_option_CRAM_OPT_USE_BZIP2: hts_fmt_option = 12; +pub const hts_fmt_option_CRAM_OPT_SHARED_REF: hts_fmt_option = 13; +pub const hts_fmt_option_CRAM_OPT_NTHREADS: hts_fmt_option = 14; +pub const hts_fmt_option_CRAM_OPT_THREAD_POOL: hts_fmt_option = 15; +pub const hts_fmt_option_CRAM_OPT_USE_LZMA: hts_fmt_option = 16; +pub const hts_fmt_option_CRAM_OPT_USE_RANS: hts_fmt_option = 17; +pub const hts_fmt_option_CRAM_OPT_REQUIRED_FIELDS: hts_fmt_option = 18; +pub const hts_fmt_option_CRAM_OPT_LOSSY_NAMES: hts_fmt_option = 19; +pub const hts_fmt_option_CRAM_OPT_BASES_PER_SLICE: hts_fmt_option = 20; +pub const hts_fmt_option_CRAM_OPT_STORE_MD: hts_fmt_option = 21; +pub const hts_fmt_option_CRAM_OPT_STORE_NM: hts_fmt_option = 22; +pub const hts_fmt_option_CRAM_OPT_RANGE_NOSEEK: hts_fmt_option = 23; +pub const hts_fmt_option_CRAM_OPT_USE_TOK: hts_fmt_option = 24; +pub const hts_fmt_option_CRAM_OPT_USE_FQZ: hts_fmt_option = 25; +pub const hts_fmt_option_CRAM_OPT_USE_ARITH: hts_fmt_option = 26; +pub const hts_fmt_option_CRAM_OPT_POS_DELTA: hts_fmt_option = 27; +pub const hts_fmt_option_HTS_OPT_COMPRESSION_LEVEL: hts_fmt_option = 100; +pub const hts_fmt_option_HTS_OPT_NTHREADS: hts_fmt_option = 101; +pub const hts_fmt_option_HTS_OPT_THREAD_POOL: hts_fmt_option = 102; +pub const hts_fmt_option_HTS_OPT_CACHE_SIZE: hts_fmt_option = 103; +pub const hts_fmt_option_HTS_OPT_BLOCK_SIZE: hts_fmt_option = 104; +pub const hts_fmt_option_HTS_OPT_FILTER: hts_fmt_option = 105; +pub const hts_fmt_option_HTS_OPT_PROFILE: hts_fmt_option = 106; +pub const hts_fmt_option_FASTQ_OPT_CASAVA: hts_fmt_option = 1000; +pub const hts_fmt_option_FASTQ_OPT_AUX: hts_fmt_option = 1001; +pub const hts_fmt_option_FASTQ_OPT_RNUM: hts_fmt_option = 1002; +pub const hts_fmt_option_FASTQ_OPT_BARCODE: hts_fmt_option = 1003; +pub const hts_fmt_option_FASTQ_OPT_NAME2: hts_fmt_option = 1004; +pub type hts_fmt_option = ::std::os::raw::c_uint; +pub const hts_profile_option_HTS_PROFILE_FAST: hts_profile_option = 0; +pub const hts_profile_option_HTS_PROFILE_NORMAL: hts_profile_option = 1; +pub const hts_profile_option_HTS_PROFILE_SMALL: hts_profile_option = 2; +pub const hts_profile_option_HTS_PROFILE_ARCHIVE: hts_profile_option = 3; +pub type hts_profile_option = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct hts_opt { + pub arg: *mut ::std::os::raw::c_char, + pub opt: hts_fmt_option, + pub val: hts_opt__bindgen_ty_1, + pub next: *mut hts_opt, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union hts_opt__bindgen_ty_1 { + pub i: ::std::os::raw::c_int, + pub s: *mut ::std::os::raw::c_char, +} +unsafe extern "C" { + pub fn hts_opt_add( + opts: *mut *mut hts_opt, + c_arg: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_opt_apply(fp: *mut htsFile, opts: *mut hts_opt) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_opt_free(opts: *mut hts_opt); +} +unsafe extern "C" { + pub fn hts_parse_format( + opt: *mut htsFormat, + str_: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_parse_opt_list( + opt: *mut htsFormat, + str_: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub static seq_nt16_table: [::std::os::raw::c_uchar; 256usize]; +} +unsafe extern "C" { + pub static seq_nt16_str: [::std::os::raw::c_char; 0usize]; +} +unsafe extern "C" { + pub static seq_nt16_int: [::std::os::raw::c_int; 0usize]; +} +unsafe extern "C" { + pub fn hts_version() -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_features() -> ::std::os::raw::c_uint; +} +unsafe extern "C" { + pub fn hts_test_feature(id: ::std::os::raw::c_uint) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_feature_string() -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_detect_format(fp: *mut hFILE, fmt: *mut htsFormat) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_detect_format2( + fp: *mut hFILE, + fname: *const ::std::os::raw::c_char, + fmt: *mut htsFormat, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_format_description(format: *const htsFormat) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_open( + fn_: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut htsFile; +} +unsafe extern "C" { + pub fn hts_open_format( + fn_: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + fmt: *const htsFormat, + ) -> *mut htsFile; +} +unsafe extern "C" { + pub fn hts_hopen( + fp: *mut hFILE, + fn_: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut htsFile; +} +unsafe extern "C" { + pub fn hts_flush(fp: *mut htsFile) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_close(fp: *mut htsFile) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_get_format(fp: *mut htsFile) -> *const htsFormat; +} +unsafe extern "C" { + pub fn hts_format_file_extension(format: *const htsFormat) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_set_opt(fp: *mut htsFile, opt: hts_fmt_option, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_getline( + fp: *mut htsFile, + delimiter: ::std::os::raw::c_int, + str_: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_readlines( + fn_: *const ::std::os::raw::c_char, + _n: *mut ::std::os::raw::c_int, + ) -> *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_readlist( + fn_: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + _n: *mut ::std::os::raw::c_int, + ) -> *mut *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_set_threads(fp: *mut htsFile, n: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_set_thread_pool(fp: *mut htsFile, p: *mut htsThreadPool) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_set_cache_size(fp: *mut htsFile, n: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn hts_set_fai_filename( + fp: *mut htsFile, + fn_aux: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_set_filter_expression( + fp: *mut htsFile, + expr: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_check_EOF(fp: *mut htsFile) -> ::std::os::raw::c_int; +} +pub type hts_pos_t = i64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_pair_pos_t { + pub beg: hts_pos_t, + pub end: hts_pos_t, +} +pub type hts_pair32_t = hts_pair_pos_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_pair64_t { + pub u: u64, + pub v: u64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_pair64_max_t { + pub u: u64, + pub v: u64, + pub max: u64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_reglist_t { + pub reg: *const ::std::os::raw::c_char, + pub intervals: *mut hts_pair_pos_t, + pub tid: ::std::os::raw::c_int, + pub count: u32, + pub min_beg: hts_pos_t, + pub max_end: hts_pos_t, +} +pub type hts_readrec_func = ::std::option::Option< + unsafe extern "C" fn( + fp: *mut BGZF, + data: *mut ::std::os::raw::c_void, + r: *mut ::std::os::raw::c_void, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + ) -> ::std::os::raw::c_int, +>; +pub type hts_seek_func = ::std::option::Option< + unsafe extern "C" fn( + fp: *mut ::std::os::raw::c_void, + offset: i64, + where_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, +>; +pub type hts_tell_func = + ::std::option::Option i64>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_itr_t { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub tid: ::std::os::raw::c_int, + pub n_off: ::std::os::raw::c_int, + pub i: ::std::os::raw::c_int, + pub n_reg: ::std::os::raw::c_int, + pub beg: hts_pos_t, + pub end: hts_pos_t, + pub reg_list: *mut hts_reglist_t, + pub curr_tid: ::std::os::raw::c_int, + pub curr_reg: ::std::os::raw::c_int, + pub curr_intv: ::std::os::raw::c_int, + pub curr_beg: hts_pos_t, + pub curr_end: hts_pos_t, + pub curr_off: u64, + pub nocoor_off: u64, + pub off: *mut hts_pair64_max_t, + pub readrec: hts_readrec_func, + pub seek: hts_seek_func, + pub tell: hts_tell_func, + pub bins: hts_itr_t__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_itr_t__bindgen_ty_1 { + pub n: ::std::os::raw::c_int, + pub m: ::std::os::raw::c_int, + pub a: *mut ::std::os::raw::c_int, +} +impl hts_itr_t { + #[inline] + pub fn read_rest(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_read_rest(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn read_rest_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_read_rest_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn finished(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_finished(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn finished_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_finished_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_cram(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_cram(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_cram_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_cram_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn nocoor(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_nocoor(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn nocoor_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_nocoor_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn multi(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_multi(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn multi_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_multi_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn dummy(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_dummy(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn dummy_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_dummy_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + read_rest: u32, + finished: u32, + is_cram: u32, + nocoor: u32, + multi: u32, + dummy: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let read_rest: u32 = unsafe { ::std::mem::transmute(read_rest) }; + read_rest as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let finished: u32 = unsafe { ::std::mem::transmute(finished) }; + finished as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let is_cram: u32 = unsafe { ::std::mem::transmute(is_cram) }; + is_cram as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let nocoor: u32 = unsafe { ::std::mem::transmute(nocoor) }; + nocoor as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let multi: u32 = unsafe { ::std::mem::transmute(multi) }; + multi as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let dummy: u32 = unsafe { ::std::mem::transmute(dummy) }; + dummy as u64 + }); + __bindgen_bitfield_unit + } +} +pub type hts_itr_multi_t = hts_itr_t; +unsafe extern "C" { + pub fn hts_idx_init( + n: ::std::os::raw::c_int, + fmt: ::std::os::raw::c_int, + offset0: u64, + min_shift: ::std::os::raw::c_int, + n_lvls: ::std::os::raw::c_int, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn hts_idx_destroy(idx: *mut hts_idx_t); +} +unsafe extern "C" { + pub fn hts_idx_push( + idx: *mut hts_idx_t, + tid: ::std::os::raw::c_int, + beg: hts_pos_t, + end: hts_pos_t, + offset: u64, + is_mapped: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_finish(idx: *mut hts_idx_t, final_offset: u64) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_fmt(idx: *mut hts_idx_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_tbi_name( + idx: *mut hts_idx_t, + tid: ::std::os::raw::c_int, + name: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_save( + idx: *const hts_idx_t, + fn_: *const ::std::os::raw::c_char, + fmt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_save_as( + idx: *const hts_idx_t, + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + fmt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_load( + fn_: *const ::std::os::raw::c_char, + fmt: ::std::os::raw::c_int, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn hts_idx_load2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn hts_idx_load3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + fmt: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> *mut hts_idx_t; +} +pub type hts_id2name_f = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, +>; +unsafe extern "C" { + pub fn hts_idx_get_meta(idx: *mut hts_idx_t, l_meta: *mut u32) -> *mut u8; +} +unsafe extern "C" { + pub fn hts_idx_set_meta( + idx: *mut hts_idx_t, + l_meta: u32, + meta: *mut u8, + is_copy: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_get_stat( + idx: *const hts_idx_t, + tid: ::std::os::raw::c_int, + mapped: *mut u64, + unmapped: *mut u64, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_idx_get_n_no_coor(idx: *const hts_idx_t) -> u64; +} +unsafe extern "C" { + pub fn hts_idx_seqnames( + idx: *const hts_idx_t, + n: *mut ::std::os::raw::c_int, + getid: hts_id2name_f, + hdr: *mut ::std::os::raw::c_void, + ) -> *mut *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_idx_nseq(idx: *const hts_idx_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_parse_decimal( + str_: *const ::std::os::raw::c_char, + strend: *mut *mut ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_longlong; +} +pub type hts_name2id_f = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +unsafe extern "C" { + pub fn hts_parse_reg64( + str_: *const ::std::os::raw::c_char, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_parse_reg( + str_: *const ::std::os::raw::c_char, + beg: *mut ::std::os::raw::c_int, + end: *mut ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_parse_region( + s: *const ::std::os::raw::c_char, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + getid: hts_name2id_f, + hdr: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hts_itr_query( + idx: *const hts_idx_t, + tid: ::std::os::raw::c_int, + beg: hts_pos_t, + end: hts_pos_t, + readrec: hts_readrec_func, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn hts_itr_destroy(iter: *mut hts_itr_t); +} +pub type hts_itr_query_func = ::std::option::Option< + unsafe extern "C" fn( + idx: *const hts_idx_t, + tid: ::std::os::raw::c_int, + beg: hts_pos_t, + end: hts_pos_t, + readrec: hts_readrec_func, + ) -> *mut hts_itr_t, +>; +unsafe extern "C" { + pub fn hts_itr_querys( + idx: *const hts_idx_t, + reg: *const ::std::os::raw::c_char, + getid: hts_name2id_f, + hdr: *mut ::std::os::raw::c_void, + itr_query: hts_itr_query_func, + readrec: hts_readrec_func, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn hts_itr_next( + fp: *mut BGZF, + iter: *mut hts_itr_t, + r: *mut ::std::os::raw::c_void, + data: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +pub type hts_itr_multi_query_func = ::std::option::Option< + unsafe extern "C" fn(idx: *const hts_idx_t, itr: *mut hts_itr_t) -> ::std::os::raw::c_int, +>; +unsafe extern "C" { + pub fn hts_itr_multi_bam(idx: *const hts_idx_t, iter: *mut hts_itr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_itr_multi_cram(idx: *const hts_idx_t, iter: *mut hts_itr_t) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_itr_regions( + idx: *const hts_idx_t, + reglist: *mut hts_reglist_t, + count: ::std::os::raw::c_int, + getid: hts_name2id_f, + hdr: *mut ::std::os::raw::c_void, + itr_specific: hts_itr_multi_query_func, + readrec: hts_readrec_func, + seek: hts_seek_func, + tell: hts_tell_func, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn hts_itr_multi_next( + fd: *mut htsFile, + iter: *mut hts_itr_t, + r: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_reglist_create( + argv: *mut *mut ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + r_count: *mut ::std::os::raw::c_int, + hdr: *mut ::std::os::raw::c_void, + getid: hts_name2id_f, + ) -> *mut hts_reglist_t; +} +unsafe extern "C" { + pub fn hts_reglist_free(reglist: *mut hts_reglist_t, count: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn hts_file_type(fname: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct errmod_t { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn errmod_init(depcorr: f64) -> *mut errmod_t; +} +unsafe extern "C" { + pub fn errmod_destroy(em: *mut errmod_t); +} +unsafe extern "C" { + pub fn errmod_cal( + em: *const errmod_t, + n: ::std::os::raw::c_int, + m: ::std::os::raw::c_int, + bases: *mut u16, + q: *mut f32, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct probaln_par_t { + pub d: f32, + pub e: f32, + pub bw: ::std::os::raw::c_int, +} +unsafe extern "C" { + pub fn probaln_glocal( + ref_: *const u8, + l_ref: ::std::os::raw::c_int, + query: *const u8, + l_query: ::std::os::raw::c_int, + iqual: *const u8, + c: *const probaln_par_t, + state: *mut ::std::os::raw::c_int, + q: *mut u8, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_md5_context { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn hts_md5_init() -> *mut hts_md5_context; +} +unsafe extern "C" { + pub fn hts_md5_update( + ctx: *mut hts_md5_context, + data: *const ::std::os::raw::c_void, + size: ::std::os::raw::c_ulong, + ); +} +unsafe extern "C" { + pub fn hts_md5_final(digest: *mut ::std::os::raw::c_uchar, ctx: *mut hts_md5_context); +} +unsafe extern "C" { + pub fn hts_md5_reset(ctx: *mut hts_md5_context); +} +unsafe extern "C" { + pub fn hts_md5_hex(hex: *mut ::std::os::raw::c_char, digest: *const ::std::os::raw::c_uchar); +} +unsafe extern "C" { + pub fn hts_md5_destroy(ctx: *mut hts_md5_context); +} +pub type uint16_u = u16; +pub type uint32_u = u32; +pub type uint64_u = u64; +unsafe extern "C" { + pub fn _wassert( + _Message: *const wchar_t, + _File: *const wchar_t, + _Line: ::std::os::raw::c_uint, + ) -> !; +} +unsafe extern "C" { + pub fn _assert( + _Message: *const ::std::os::raw::c_char, + _File: *const ::std::os::raw::c_char, + _Line: ::std::os::raw::c_uint, + ) -> !; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_hrec_t { + pub type_: ::std::os::raw::c_int, + pub key: *mut ::std::os::raw::c_char, + pub value: *mut ::std::os::raw::c_char, + pub nkeys: ::std::os::raw::c_int, + pub keys: *mut *mut ::std::os::raw::c_char, + pub vals: *mut *mut ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_idinfo_t { + pub info: [u64; 3usize], + pub hrec: [*mut bcf_hrec_t; 3usize], + pub id: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_idpair_t { + pub key: *const ::std::os::raw::c_char, + pub val: *const bcf_idinfo_t, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_hdr_t { + pub n: [i32; 3usize], + pub id: [*mut bcf_idpair_t; 3usize], + pub dict: [*mut ::std::os::raw::c_void; 3usize], + pub samples: *mut *mut ::std::os::raw::c_char, + pub hrec: *mut *mut bcf_hrec_t, + pub nhrec: ::std::os::raw::c_int, + pub dirty: ::std::os::raw::c_int, + pub ntransl: ::std::os::raw::c_int, + pub transl: [*mut ::std::os::raw::c_int; 2usize], + pub nsamples_ori: ::std::os::raw::c_int, + pub keep_samples: *mut u8, + pub mem: kstring_t, + pub m: [i32; 3usize], +} +unsafe extern "C" { + pub static mut bcf_type_shift: [u8; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_variant_t { + pub type_: ::std::os::raw::c_int, + pub n: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_fmt_t { + pub id: ::std::os::raw::c_int, + pub n: ::std::os::raw::c_int, + pub size: ::std::os::raw::c_int, + pub type_: ::std::os::raw::c_int, + pub p: *mut u8, + pub p_len: u32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +impl bcf_fmt_t { + #[inline] + pub fn p_off(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) } + } + #[inline] + pub fn set_p_off(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn p_off_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_p_off_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn p_free(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_p_free(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn p_free_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_p_free_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(p_off: u32, p_free: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 31u8, { + let p_off: u32 = unsafe { ::std::mem::transmute(p_off) }; + p_off as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let p_free: u32 = unsafe { ::std::mem::transmute(p_free) }; + p_free as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bcf_info_t { + pub key: ::std::os::raw::c_int, + pub type_: ::std::os::raw::c_int, + pub v1: bcf_info_t__bindgen_ty_1, + pub vptr: *mut u8, + pub vptr_len: u32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub len: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bcf_info_t__bindgen_ty_1 { + pub i: i64, + pub f: f32, +} +impl bcf_info_t { + #[inline] + pub fn vptr_off(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) } + } + #[inline] + pub fn set_vptr_off(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 31u8, val as u64) + } + } + #[inline] + pub unsafe fn vptr_off_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 31u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vptr_off_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 31u8, + val as u64, + ) + } + } + #[inline] + pub fn vptr_free(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_vptr_free(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn vptr_free_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_vptr_free_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(vptr_off: u32, vptr_free: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 31u8, { + let vptr_off: u32 = unsafe { ::std::mem::transmute(vptr_off) }; + vptr_off as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let vptr_free: u32 = unsafe { ::std::mem::transmute(vptr_free) }; + vptr_free as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_dec_t { + pub m_fmt: ::std::os::raw::c_int, + pub m_info: ::std::os::raw::c_int, + pub m_id: ::std::os::raw::c_int, + pub m_als: ::std::os::raw::c_int, + pub m_allele: ::std::os::raw::c_int, + pub m_flt: ::std::os::raw::c_int, + pub n_flt: ::std::os::raw::c_int, + pub flt: *mut ::std::os::raw::c_int, + pub id: *mut ::std::os::raw::c_char, + pub als: *mut ::std::os::raw::c_char, + pub allele: *mut *mut ::std::os::raw::c_char, + pub info: *mut bcf_info_t, + pub fmt: *mut bcf_fmt_t, + pub var: *mut bcf_variant_t, + pub n_var: ::std::os::raw::c_int, + pub var_type: ::std::os::raw::c_int, + pub shared_dirty: ::std::os::raw::c_int, + pub indiv_dirty: ::std::os::raw::c_int, +} +unsafe extern "C" { + pub fn bcf_strerror( + errorcode: ::std::os::raw::c_int, + buffer: *mut ::std::os::raw::c_char, + maxbuffer: usize, + ) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf1_t { + pub pos: hts_pos_t, + pub rlen: hts_pos_t, + pub rid: i32, + pub qual: f32, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + pub shared: kstring_t, + pub indiv: kstring_t, + pub d: bcf_dec_t, + pub max_unpack: ::std::os::raw::c_int, + pub unpacked: ::std::os::raw::c_int, + pub unpack_size: [::std::os::raw::c_int; 3usize], + pub errcode: ::std::os::raw::c_int, +} +impl bcf1_t { + #[inline] + pub fn n_info(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) } + } + #[inline] + pub fn set_n_info(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn n_info_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_n_info_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn n_allele(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) } + } + #[inline] + pub fn set_n_allele(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn n_allele_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_n_allele_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn n_fmt(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) } + } + #[inline] + pub fn set_n_fmt(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 8u8, val as u64) + } + } + #[inline] + pub unsafe fn n_fmt_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_n_fmt_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 8u8, + val as u64, + ) + } + } + #[inline] + pub fn n_sample(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 24u8) as u32) } + } + #[inline] + pub fn set_n_sample(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 24u8, val as u64) + } + } + #[inline] + pub unsafe fn n_sample_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 40usize, + 24u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_n_sample_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 40usize, + 24u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + n_info: u32, + n_allele: u32, + n_fmt: u32, + n_sample: u32, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 16u8, { + let n_info: u32 = unsafe { ::std::mem::transmute(n_info) }; + n_info as u64 + }); + __bindgen_bitfield_unit.set(16usize, 16u8, { + let n_allele: u32 = unsafe { ::std::mem::transmute(n_allele) }; + n_allele as u64 + }); + __bindgen_bitfield_unit.set(32usize, 8u8, { + let n_fmt: u32 = unsafe { ::std::mem::transmute(n_fmt) }; + n_fmt as u64 + }); + __bindgen_bitfield_unit.set(40usize, 24u8, { + let n_sample: u32 = unsafe { ::std::mem::transmute(n_sample) }; + n_sample as u64 + }); + __bindgen_bitfield_unit + } +} +unsafe extern "C" { + pub fn bcf_hdr_init(mode: *const ::std::os::raw::c_char) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn bcf_hdr_destroy(h: *mut bcf_hdr_t); +} +unsafe extern "C" { + pub fn bcf_init() -> *mut bcf1_t; +} +unsafe extern "C" { + pub fn bcf_destroy(v: *mut bcf1_t); +} +unsafe extern "C" { + pub fn bcf_empty(v: *mut bcf1_t); +} +unsafe extern "C" { + pub fn bcf_clear(v: *mut bcf1_t); +} +pub type vcfFile = htsFile; +unsafe extern "C" { + pub fn bcf_hdr_read(fp: *mut htsFile) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn bcf_hdr_set_samples( + hdr: *mut bcf_hdr_t, + samples: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_subset_format(hdr: *const bcf_hdr_t, rec: *mut bcf1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_write(fp: *mut htsFile, h: *mut bcf_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_parse( + s: *mut kstring_t, + h: *const bcf_hdr_t, + v: *mut bcf1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_open_mode( + mode: *mut ::std::os::raw::c_char, + fn_: *const ::std::os::raw::c_char, + format: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_format( + h: *const bcf_hdr_t, + v: *const bcf1_t, + s: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_read(fp: *mut htsFile, h: *const bcf_hdr_t, v: *mut bcf1_t) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_unpack(b: *mut bcf1_t, which: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_dup(src: *mut bcf1_t) -> *mut bcf1_t; +} +unsafe extern "C" { + pub fn bcf_copy(dst: *mut bcf1_t, src: *mut bcf1_t) -> *mut bcf1_t; +} +unsafe extern "C" { + pub fn bcf_write(fp: *mut htsFile, h: *mut bcf_hdr_t, v: *mut bcf1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_hdr_read(fp: *mut htsFile) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn vcf_hdr_write(fp: *mut htsFile, h: *const bcf_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_read(fp: *mut htsFile, h: *const bcf_hdr_t, v: *mut bcf1_t) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_write( + fp: *mut htsFile, + h: *const bcf_hdr_t, + v: *mut bcf1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_readrec( + fp: *mut BGZF, + null: *mut ::std::os::raw::c_void, + v: *mut ::std::os::raw::c_void, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn vcf_write_line(fp: *mut htsFile, line: *mut kstring_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_dup(hdr: *const bcf_hdr_t) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn bcf_hdr_combine(dst: *mut bcf_hdr_t, src: *const bcf_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_merge(dst: *mut bcf_hdr_t, src: *const bcf_hdr_t) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn bcf_hdr_add_sample( + hdr: *mut bcf_hdr_t, + sample: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_set( + hdr: *mut bcf_hdr_t, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_format( + hdr: *const bcf_hdr_t, + is_bcf: ::std::os::raw::c_int, + str_: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_fmt_text( + hdr: *const bcf_hdr_t, + is_bcf: ::std::os::raw::c_int, + len: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bcf_hdr_append( + h: *mut bcf_hdr_t, + line: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_printf( + h: *mut bcf_hdr_t, + format: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_get_version(hdr: *const bcf_hdr_t) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bcf_hdr_set_version( + hdr: *mut bcf_hdr_t, + version: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_remove( + h: *mut bcf_hdr_t, + type_: ::std::os::raw::c_int, + key: *const ::std::os::raw::c_char, + ); +} +unsafe extern "C" { + pub fn bcf_hdr_subset( + h0: *const bcf_hdr_t, + n: ::std::os::raw::c_int, + samples: *const *mut ::std::os::raw::c_char, + imap: *mut ::std::os::raw::c_int, + ) -> *mut bcf_hdr_t; +} +unsafe extern "C" { + pub fn bcf_hdr_seqnames( + h: *const bcf_hdr_t, + nseqs: *mut ::std::os::raw::c_int, + ) -> *mut *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bcf_hdr_parse( + hdr: *mut bcf_hdr_t, + htxt: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_sync(h: *mut bcf_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_parse_line( + h: *const bcf_hdr_t, + line: *const ::std::os::raw::c_char, + len: *mut ::std::os::raw::c_int, + ) -> *mut bcf_hrec_t; +} +unsafe extern "C" { + pub fn bcf_hrec_format(hrec: *const bcf_hrec_t, str_: *mut kstring_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_add_hrec(hdr: *mut bcf_hdr_t, hrec: *mut bcf_hrec_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_get_hrec( + hdr: *const bcf_hdr_t, + type_: ::std::os::raw::c_int, + key: *const ::std::os::raw::c_char, + value: *const ::std::os::raw::c_char, + str_class: *const ::std::os::raw::c_char, + ) -> *mut bcf_hrec_t; +} +unsafe extern "C" { + pub fn bcf_hrec_dup(hrec: *mut bcf_hrec_t) -> *mut bcf_hrec_t; +} +unsafe extern "C" { + pub fn bcf_hrec_add_key( + hrec: *mut bcf_hrec_t, + str_: *const ::std::os::raw::c_char, + len: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hrec_set_val( + hrec: *mut bcf_hrec_t, + i: ::std::os::raw::c_int, + str_: *const ::std::os::raw::c_char, + len: usize, + is_quoted: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hrec_find_key( + hrec: *mut bcf_hrec_t, + key: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hrec_add_idx(hrec: *mut bcf_hrec_t, idx: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hrec_destroy(hrec: *mut bcf_hrec_t); +} +unsafe extern "C" { + pub fn bcf_subset( + h: *const bcf_hdr_t, + v: *mut bcf1_t, + n: ::std::os::raw::c_int, + imap: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_translate( + dst_hdr: *const bcf_hdr_t, + src_hdr: *mut bcf_hdr_t, + src_line: *mut bcf1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_get_variant_types(rec: *mut bcf1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_get_variant_type( + rec: *mut bcf1_t, + ith_allele: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +pub const bcf_variant_match_bcf_match_exact: bcf_variant_match = 0; +pub const bcf_variant_match_bcf_match_overlap: bcf_variant_match = 1; +pub const bcf_variant_match_bcf_match_subset: bcf_variant_match = 2; +pub type bcf_variant_match = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn bcf_has_variant_types( + rec: *mut bcf1_t, + bitmask: u32, + mode: bcf_variant_match, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_has_variant_type( + rec: *mut bcf1_t, + ith_allele: ::std::os::raw::c_int, + bitmask: u32, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_variant_length( + rec: *mut bcf1_t, + ith_allele: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_is_snp(v: *mut bcf1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_filter( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + flt_ids: *mut ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_add_filter( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + flt_id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_remove_filter( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + flt_id: ::std::os::raw::c_int, + pass: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_has_filter( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + filter: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_alleles( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + alleles: *mut *const ::std::os::raw::c_char, + nals: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_alleles_str( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + alleles_string: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_id( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + id: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_add_id( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + id: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_info( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + key: *const ::std::os::raw::c_char, + values: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + type_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_format_string( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + key: *const ::std::os::raw::c_char, + values: *mut *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_update_format( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + key: *const ::std::os::raw::c_char, + values: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + type_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_get_fmt( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + key: *const ::std::os::raw::c_char, + ) -> *mut bcf_fmt_t; +} +unsafe extern "C" { + pub fn bcf_get_info( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + key: *const ::std::os::raw::c_char, + ) -> *mut bcf_info_t; +} +unsafe extern "C" { + pub fn bcf_get_fmt_id(line: *mut bcf1_t, id: ::std::os::raw::c_int) -> *mut bcf_fmt_t; +} +unsafe extern "C" { + pub fn bcf_get_info_id(line: *mut bcf1_t, id: ::std::os::raw::c_int) -> *mut bcf_info_t; +} +unsafe extern "C" { + pub fn bcf_get_info_values( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + tag: *const ::std::os::raw::c_char, + dst: *mut *mut ::std::os::raw::c_void, + ndst: *mut ::std::os::raw::c_int, + type_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_get_format_string( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + tag: *const ::std::os::raw::c_char, + dst: *mut *mut *mut ::std::os::raw::c_char, + ndst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_get_format_values( + hdr: *const bcf_hdr_t, + line: *mut bcf1_t, + tag: *const ::std::os::raw::c_char, + dst: *mut *mut ::std::os::raw::c_void, + ndst: *mut ::std::os::raw::c_int, + type_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_hdr_id2int( + hdr: *const bcf_hdr_t, + type_: ::std::os::raw::c_int, + id: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_fmt_array( + s: *mut kstring_t, + n: ::std::os::raw::c_int, + type_: ::std::os::raw::c_int, + data: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_fmt_sized_array(s: *mut kstring_t, ptr: *mut u8) -> *mut u8; +} +unsafe extern "C" { + pub fn bcf_enc_vchar( + s: *mut kstring_t, + l: ::std::os::raw::c_int, + a: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_enc_vint( + s: *mut kstring_t, + n: ::std::os::raw::c_int, + a: *mut i32, + wsize: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_enc_vfloat( + s: *mut kstring_t, + n: ::std::os::raw::c_int, + a: *mut f32, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_index_load2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn bcf_index_load3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn bcf_index_build( + fn_: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_index_build2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_index_build3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + n_threads: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_idx_init( + fp: *mut htsFile, + h: *mut bcf_hdr_t, + min_shift: ::std::os::raw::c_int, + fnidx: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_idx_save(fp: *mut htsFile) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub static mut bcf_float_vector_end: u32; +} +unsafe extern "C" { + pub static mut bcf_float_missing: u32; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sam_hrecs_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sam_hdr_t { + pub n_targets: i32, + pub ignore_sam_err: i32, + pub l_text: usize, + pub target_len: *mut u32, + pub cigar_tab: *const i8, + pub target_name: *mut *mut ::std::os::raw::c_char, + pub text: *mut ::std::os::raw::c_char, + pub sdict: *mut ::std::os::raw::c_void, + pub hrecs: *mut sam_hrecs_t, + pub ref_count: u32, +} +pub type bam_hdr_t = sam_hdr_t; +unsafe extern "C" { + pub static bam_cigar_table: [i8; 256usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bam1_core_t { + pub pos: hts_pos_t, + pub tid: i32, + pub bin: u16, + pub qual: u8, + pub l_extranul: u8, + pub flag: u16, + pub l_qname: u16, + pub n_cigar: u32, + pub l_qseq: i32, + pub mtid: i32, + pub mpos: hts_pos_t, + pub isize_: hts_pos_t, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bam1_t { + pub core: bam1_core_t, + pub id: u64, + pub data: *mut u8, + pub l_data: ::std::os::raw::c_int, + pub m_data: u32, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub __bindgen_padding_0: u32, +} +impl bam1_t { + #[inline] + pub fn mempolicy(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } + } + #[inline] + pub fn set_mempolicy(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 2u8, val as u64) + } + } + #[inline] + pub unsafe fn mempolicy_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 2u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mempolicy_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 2u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1(mempolicy: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 2u8, { + let mempolicy: u32 = unsafe { ::std::mem::transmute(mempolicy) }; + mempolicy as u64 + }); + __bindgen_bitfield_unit + } +} +unsafe extern "C" { + pub fn sam_hdr_init() -> *mut sam_hdr_t; +} +unsafe extern "C" { + pub fn bam_hdr_read(fp: *mut BGZF) -> *mut sam_hdr_t; +} +unsafe extern "C" { + pub fn bam_hdr_write(fp: *mut BGZF, h: *const sam_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_destroy(h: *mut sam_hdr_t); +} +unsafe extern "C" { + pub fn sam_hdr_dup(h0: *const sam_hdr_t) -> *mut sam_hdr_t; +} +pub type samFile = htsFile; +unsafe extern "C" { + pub fn sam_hdr_parse(l_text: usize, text: *const ::std::os::raw::c_char) -> *mut sam_hdr_t; +} +unsafe extern "C" { + pub fn sam_hdr_read(fp: *mut samFile) -> *mut sam_hdr_t; +} +unsafe extern "C" { + pub fn sam_hdr_write(fp: *mut samFile, h: *const sam_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_length(h: *mut sam_hdr_t) -> usize; +} +unsafe extern "C" { + pub fn sam_hdr_str(h: *mut sam_hdr_t) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_nref(h: *const sam_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_add_lines( + h: *mut sam_hdr_t, + lines: *const ::std::os::raw::c_char, + len: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_add_line( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_find_line_id( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_val: *const ::std::os::raw::c_char, + ks: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_find_line_pos( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + pos: ::std::os::raw::c_int, + ks: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_remove_line_id( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_value: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_remove_line_pos( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + position: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_update_line( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_value: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_remove_except( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_value: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_remove_lines( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + id: *const ::std::os::raw::c_char, + rh: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_count_lines( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_line_index( + bh: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + key: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_line_name( + bh: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + pos: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_find_tag_id( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_value: *const ::std::os::raw::c_char, + key: *const ::std::os::raw::c_char, + ks: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_find_tag_pos( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + pos: ::std::os::raw::c_int, + key: *const ::std::os::raw::c_char, + ks: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_remove_tag_id( + h: *mut sam_hdr_t, + type_: *const ::std::os::raw::c_char, + ID_key: *const ::std::os::raw::c_char, + ID_value: *const ::std::os::raw::c_char, + key: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_name2tid( + h: *mut sam_hdr_t, + ref_: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_hdr_tid2name( + h: *const sam_hdr_t, + tid: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_tid2len(h: *const sam_hdr_t, tid: ::std::os::raw::c_int) -> hts_pos_t; +} +unsafe extern "C" { + pub fn sam_hdr_pg_id( + h: *mut sam_hdr_t, + name: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_add_pg( + h: *mut sam_hdr_t, + name: *const ::std::os::raw::c_char, + ... + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stringify_argv( + argc: ::std::os::raw::c_int, + argv: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_incr_ref(h: *mut sam_hdr_t); +} +unsafe extern "C" { + pub fn bam_init1() -> *mut bam1_t; +} +unsafe extern "C" { + pub fn bam_destroy1(b: *mut bam1_t); +} +unsafe extern "C" { + pub fn bam_read1(fp: *mut BGZF, b: *mut bam1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_write1(fp: *mut BGZF, b: *const bam1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_copy1(bdst: *mut bam1_t, bsrc: *const bam1_t) -> *mut bam1_t; +} +unsafe extern "C" { + pub fn bam_dup1(bsrc: *const bam1_t) -> *mut bam1_t; +} +unsafe extern "C" { + pub fn bam_set1( + bam: *mut bam1_t, + l_qname: usize, + qname: *const ::std::os::raw::c_char, + flag: u16, + tid: i32, + pos: hts_pos_t, + mapq: u8, + n_cigar: usize, + cigar: *const u32, + mtid: i32, + mpos: hts_pos_t, + isize_: hts_pos_t, + l_seq: usize, + seq: *const ::std::os::raw::c_char, + qual: *const ::std::os::raw::c_char, + l_aux: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_cigar2qlen(n_cigar: ::std::os::raw::c_int, cigar: *const u32) -> hts_pos_t; +} +unsafe extern "C" { + pub fn bam_cigar2rlen(n_cigar: ::std::os::raw::c_int, cigar: *const u32) -> hts_pos_t; +} +unsafe extern "C" { + pub fn bam_endpos(b: *const bam1_t) -> hts_pos_t; +} +unsafe extern "C" { + pub fn bam_str2flag(str_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_flag2str(flag: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bam_set_qname( + b: *mut bam1_t, + qname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_parse_cigar( + in_: *const ::std::os::raw::c_char, + end: *mut *mut ::std::os::raw::c_char, + a_cigar: *mut *mut u32, + a_mem: *mut usize, + ) -> isize; +} +unsafe extern "C" { + pub fn bam_parse_cigar( + in_: *const ::std::os::raw::c_char, + end: *mut *mut ::std::os::raw::c_char, + b: *mut bam1_t, + ) -> isize; +} +unsafe extern "C" { + pub fn sam_idx_init( + fp: *mut htsFile, + h: *mut sam_hdr_t, + min_shift: ::std::os::raw::c_int, + fnidx: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_idx_save(fp: *mut htsFile) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_index_load(fp: *mut htsFile, fn_: *const ::std::os::raw::c_char) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn sam_index_load2( + fp: *mut htsFile, + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn sam_index_load3( + fp: *mut htsFile, + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + ) -> *mut hts_idx_t; +} +unsafe extern "C" { + pub fn sam_index_build( + fn_: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_index_build2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_index_build3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + nthreads: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_itr_queryi( + idx: *const hts_idx_t, + tid: ::std::os::raw::c_int, + beg: hts_pos_t, + end: hts_pos_t, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn sam_itr_querys( + idx: *const hts_idx_t, + hdr: *mut sam_hdr_t, + region: *const ::std::os::raw::c_char, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn sam_itr_regions( + idx: *const hts_idx_t, + hdr: *mut sam_hdr_t, + reglist: *mut hts_reglist_t, + regcount: ::std::os::raw::c_uint, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn sam_itr_regarray( + idx: *const hts_idx_t, + hdr: *mut sam_hdr_t, + regarray: *mut *mut ::std::os::raw::c_char, + regcount: ::std::os::raw::c_uint, + ) -> *mut hts_itr_t; +} +unsafe extern "C" { + pub fn sam_parse_region( + h: *mut sam_hdr_t, + s: *const ::std::os::raw::c_char, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + flags: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_open_mode( + mode: *mut ::std::os::raw::c_char, + fn_: *const ::std::os::raw::c_char, + format: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_open_mode_opts( + fn_: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + format: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn sam_hdr_change_HD( + h: *mut sam_hdr_t, + key: *const ::std::os::raw::c_char, + val: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_parse1( + s: *mut kstring_t, + h: *mut sam_hdr_t, + b: *mut bam1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_format1( + h: *const sam_hdr_t, + b: *const bam1_t, + str_: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_read1(fp: *mut samFile, h: *mut sam_hdr_t, b: *mut bam1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_write1( + fp: *mut samFile, + h: *const sam_hdr_t, + b: *const bam1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn sam_passes_filter( + h: *const sam_hdr_t, + b: *const bam1_t, + filt: *mut hts_filter_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_first(b: *const bam1_t) -> *mut u8; +} +unsafe extern "C" { + pub fn bam_aux_next(b: *const bam1_t, s: *const u8) -> *mut u8; +} +unsafe extern "C" { + pub fn bam_aux_get(b: *const bam1_t, tag: *const ::std::os::raw::c_char) -> *mut u8; +} +unsafe extern "C" { + pub fn bam_aux2i(s: *const u8) -> i64; +} +unsafe extern "C" { + pub fn bam_aux2f(s: *const u8) -> f64; +} +unsafe extern "C" { + pub fn bam_aux2A(s: *const u8) -> ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bam_aux2Z(s: *const u8) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bam_auxB_len(s: *const u8) -> u32; +} +unsafe extern "C" { + pub fn bam_auxB2i(s: *const u8, idx: u32) -> i64; +} +unsafe extern "C" { + pub fn bam_auxB2f(s: *const u8, idx: u32) -> f64; +} +unsafe extern "C" { + pub fn bam_aux_append( + b: *mut bam1_t, + tag: *const ::std::os::raw::c_char, + type_: ::std::os::raw::c_char, + len: ::std::os::raw::c_int, + data: *const u8, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_del(b: *mut bam1_t, s: *mut u8) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_remove(b: *mut bam1_t, s: *mut u8) -> *mut u8; +} +unsafe extern "C" { + pub fn bam_aux_update_str( + b: *mut bam1_t, + tag: *const ::std::os::raw::c_char, + len: ::std::os::raw::c_int, + data: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_update_int( + b: *mut bam1_t, + tag: *const ::std::os::raw::c_char, + val: i64, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_update_float( + b: *mut bam1_t, + tag: *const ::std::os::raw::c_char, + val: f32, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_aux_update_array( + b: *mut bam1_t, + tag: *const ::std::os::raw::c_char, + type_: u8, + items: u32, + data: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union bam_pileup_cd { + pub p: *mut ::std::os::raw::c_void, + pub i: i64, + pub f: f64, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct bam_pileup1_t { + pub b: *mut bam1_t, + pub qpos: i32, + pub indel: ::std::os::raw::c_int, + pub level: ::std::os::raw::c_int, + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub cd: bam_pileup_cd, + pub cigar_ind: ::std::os::raw::c_int, +} +impl bam_pileup1_t { + #[inline] + pub fn is_del(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_del(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_del_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_del_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_head(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_head(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_head_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_head_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_tail(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_tail(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_tail_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_tail_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_refskip(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_refskip(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_refskip_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_refskip_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn aux(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) } + } + #[inline] + pub fn set_aux(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 27u8, val as u64) + } + } + #[inline] + pub unsafe fn aux_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 27u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_aux_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 27u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + is_del: u32, + is_head: u32, + is_tail: u32, + is_refskip: u32, + aux: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_del: u32 = unsafe { ::std::mem::transmute(is_del) }; + is_del as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_head: u32 = unsafe { ::std::mem::transmute(is_head) }; + is_head as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let is_tail: u32 = unsafe { ::std::mem::transmute(is_tail) }; + is_tail as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is_refskip: u32 = unsafe { ::std::mem::transmute(is_refskip) }; + is_refskip as u64 + }); + __bindgen_bitfield_unit.set(5usize, 27u8, { + let aux: u32 = unsafe { ::std::mem::transmute(aux) }; + aux as u64 + }); + __bindgen_bitfield_unit + } +} +pub type bam_plp_auto_f = ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + b: *mut bam1_t, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bam_plp_s { + _unused: [u8; 0], +} +pub type bam_plp_t = *mut bam_plp_s; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bam_mplp_s { + _unused: [u8; 0], +} +pub type bam_mplp_t = *mut bam_mplp_s; +unsafe extern "C" { + pub fn bam_plp_init(func: bam_plp_auto_f, data: *mut ::std::os::raw::c_void) -> bam_plp_t; +} +unsafe extern "C" { + pub fn bam_plp_destroy(iter: bam_plp_t); +} +unsafe extern "C" { + pub fn bam_plp_push(iter: bam_plp_t, b: *const bam1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_plp_next( + iter: bam_plp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut ::std::os::raw::c_int, + _n_plp: *mut ::std::os::raw::c_int, + ) -> *const bam_pileup1_t; +} +unsafe extern "C" { + pub fn bam_plp_auto( + iter: bam_plp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut ::std::os::raw::c_int, + _n_plp: *mut ::std::os::raw::c_int, + ) -> *const bam_pileup1_t; +} +unsafe extern "C" { + pub fn bam_plp64_next( + iter: bam_plp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut hts_pos_t, + _n_plp: *mut ::std::os::raw::c_int, + ) -> *const bam_pileup1_t; +} +unsafe extern "C" { + pub fn bam_plp64_auto( + iter: bam_plp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut hts_pos_t, + _n_plp: *mut ::std::os::raw::c_int, + ) -> *const bam_pileup1_t; +} +unsafe extern "C" { + pub fn bam_plp_set_maxcnt(iter: bam_plp_t, maxcnt: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn bam_plp_reset(iter: bam_plp_t); +} +unsafe extern "C" { + pub fn bam_plp_constructor( + plp: bam_plp_t, + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + b: *const bam1_t, + cd: *mut bam_pileup_cd, + ) -> ::std::os::raw::c_int, + >, + ); +} +unsafe extern "C" { + pub fn bam_plp_destructor( + plp: bam_plp_t, + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + b: *const bam1_t, + cd: *mut bam_pileup_cd, + ) -> ::std::os::raw::c_int, + >, + ); +} +unsafe extern "C" { + pub fn bam_plp_insertion( + p: *const bam_pileup1_t, + ins: *mut kstring_t, + del_len: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_base_mod_state { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn bam_plp_insertion_mod( + p: *const bam_pileup1_t, + m: *mut hts_base_mod_state, + ins: *mut kstring_t, + del_len: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mplp_init( + n: ::std::os::raw::c_int, + func: bam_plp_auto_f, + data: *mut *mut ::std::os::raw::c_void, + ) -> bam_mplp_t; +} +unsafe extern "C" { + pub fn bam_mplp_init_overlaps(iter: bam_mplp_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mplp_destroy(iter: bam_mplp_t); +} +unsafe extern "C" { + pub fn bam_mplp_set_maxcnt(iter: bam_mplp_t, maxcnt: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn bam_mplp_auto( + iter: bam_mplp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut ::std::os::raw::c_int, + n_plp: *mut ::std::os::raw::c_int, + plp: *mut *const bam_pileup1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mplp64_auto( + iter: bam_mplp_t, + _tid: *mut ::std::os::raw::c_int, + _pos: *mut hts_pos_t, + n_plp: *mut ::std::os::raw::c_int, + plp: *mut *const bam_pileup1_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mplp_reset(iter: bam_mplp_t); +} +unsafe extern "C" { + pub fn bam_mplp_constructor( + iter: bam_mplp_t, + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + b: *const bam1_t, + cd: *mut bam_pileup_cd, + ) -> ::std::os::raw::c_int, + >, + ); +} +unsafe extern "C" { + pub fn bam_mplp_destructor( + iter: bam_mplp_t, + func: ::std::option::Option< + unsafe extern "C" fn( + data: *mut ::std::os::raw::c_void, + b: *const bam1_t, + cd: *mut bam_pileup_cd, + ) -> ::std::os::raw::c_int, + >, + ); +} +unsafe extern "C" { + pub fn sam_cap_mapq( + b: *mut bam1_t, + ref_: *const ::std::os::raw::c_char, + ref_len: hts_pos_t, + thres: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +pub const htsRealnFlags_BAQ_APPLY: htsRealnFlags = 1; +pub const htsRealnFlags_BAQ_EXTEND: htsRealnFlags = 2; +pub const htsRealnFlags_BAQ_REDO: htsRealnFlags = 4; +pub const htsRealnFlags_BAQ_AUTO: htsRealnFlags = 0; +pub const htsRealnFlags_BAQ_ILLUMINA: htsRealnFlags = 8; +pub const htsRealnFlags_BAQ_PACBIOCCS: htsRealnFlags = 16; +pub const htsRealnFlags_BAQ_PACBIO: htsRealnFlags = 24; +pub const htsRealnFlags_BAQ_ONT: htsRealnFlags = 32; +pub const htsRealnFlags_BAQ_GENAPSYS: htsRealnFlags = 40; +pub type htsRealnFlags = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn sam_prob_realn( + b: *mut bam1_t, + ref_: *const ::std::os::raw::c_char, + ref_len: hts_pos_t, + flag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_base_mod { + pub modified_base: ::std::os::raw::c_int, + pub canonical_base: ::std::os::raw::c_int, + pub strand: ::std::os::raw::c_int, + pub qual: ::std::os::raw::c_int, +} +unsafe extern "C" { + pub fn hts_base_mod_state_alloc() -> *mut hts_base_mod_state; +} +unsafe extern "C" { + pub fn hts_base_mod_state_free(state: *mut hts_base_mod_state); +} +unsafe extern "C" { + pub fn bam_parse_basemod( + b: *const bam1_t, + state: *mut hts_base_mod_state, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_parse_basemod2( + b: *const bam1_t, + state: *mut hts_base_mod_state, + flags: u32, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mods_at_next_pos( + b: *const bam1_t, + state: *mut hts_base_mod_state, + mods: *mut hts_base_mod, + n_mods: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_next_basemod( + b: *const bam1_t, + state: *mut hts_base_mod_state, + mods: *mut hts_base_mod, + n_mods: ::std::os::raw::c_int, + pos: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mods_at_qpos( + b: *const bam1_t, + qpos: ::std::os::raw::c_int, + state: *mut hts_base_mod_state, + mods: *mut hts_base_mod, + n_mods: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mods_query_type( + state: *mut hts_base_mod_state, + code: ::std::os::raw::c_int, + strand: *mut ::std::os::raw::c_int, + implicit: *mut ::std::os::raw::c_int, + canonical: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mods_queryi( + state: *mut hts_base_mod_state, + i: ::std::os::raw::c_int, + strand: *mut ::std::os::raw::c_int, + implicit: *mut ::std::os::raw::c_int, + canonical: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bam_mods_recorded( + state: *mut hts_base_mod_state, + ntype: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hFILE_backend { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hFILE { + pub buffer: *mut ::std::os::raw::c_char, + pub begin: *mut ::std::os::raw::c_char, + pub end: *mut ::std::os::raw::c_char, + pub limit: *mut ::std::os::raw::c_char, + pub backend: *const hFILE_backend, + pub offset: off_t, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub has_errno: ::std::os::raw::c_int, +} +impl hFILE { + #[inline] + pub fn at_eof(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_at_eof(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn at_eof_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_at_eof_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn mobile(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_mobile(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn mobile_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mobile_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn readonly(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_readonly(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn readonly_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_readonly_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn preserve(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_preserve(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn preserve_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_preserve_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + at_eof: ::std::os::raw::c_uint, + mobile: ::std::os::raw::c_uint, + readonly: ::std::os::raw::c_uint, + preserve: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let at_eof: u32 = unsafe { ::std::mem::transmute(at_eof) }; + at_eof as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let mobile: u32 = unsafe { ::std::mem::transmute(mobile) }; + mobile as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let readonly: u32 = unsafe { ::std::mem::transmute(readonly) }; + readonly as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let preserve: u32 = unsafe { ::std::mem::transmute(preserve) }; + preserve as u64 + }); + __bindgen_bitfield_unit + } +} +unsafe extern "C" { + pub fn hopen( + filename: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ... + ) -> *mut hFILE; +} +unsafe extern "C" { + pub fn hdopen(fd: ::std::os::raw::c_int, mode: *const ::std::os::raw::c_char) -> *mut hFILE; +} +unsafe extern "C" { + pub fn hisremote(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn haddextension( + buffer: *mut kstring_t, + filename: *const ::std::os::raw::c_char, + replace: ::std::os::raw::c_int, + extension: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hclose(fp: *mut hFILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hclose_abruptly(fp: *mut hFILE); +} +unsafe extern "C" { + pub fn hseek(fp: *mut hFILE, offset: off_t, whence: ::std::os::raw::c_int) -> off_t; +} +unsafe extern "C" { + pub fn hgetdelim( + buffer: *mut ::std::os::raw::c_char, + size: usize, + delim: ::std::os::raw::c_int, + fp: *mut hFILE, + ) -> isize; +} +unsafe extern "C" { + pub fn hgets( + buffer: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_int, + fp: *mut hFILE, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hpeek(fp: *mut hFILE, buffer: *mut ::std::os::raw::c_void, nbytes: usize) -> isize; +} +unsafe extern "C" { + pub fn hflush(fp: *mut hFILE) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hfile_mem_get_buffer( + file: *mut hFILE, + length: *mut usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hfile_mem_steal_buffer( + file: *mut hFILE, + length: *mut usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn hfile_list_schemes( + plugin: *const ::std::os::raw::c_char, + sc_list: *mut *const ::std::os::raw::c_char, + nschemes: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hfile_list_plugins( + plist: *mut *const ::std::os::raw::c_char, + nplugins: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hfile_has_plugin(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +pub const cram_block_method_CRAM_COMP_UNKNOWN: cram_block_method = -1; +pub const cram_block_method_CRAM_COMP_RAW: cram_block_method = 0; +pub const cram_block_method_CRAM_COMP_GZIP: cram_block_method = 1; +pub const cram_block_method_CRAM_COMP_BZIP2: cram_block_method = 2; +pub const cram_block_method_CRAM_COMP_LZMA: cram_block_method = 3; +pub const cram_block_method_CRAM_COMP_RANS4x8: cram_block_method = 4; +pub const cram_block_method_CRAM_COMP_RANSNx16: cram_block_method = 5; +pub const cram_block_method_CRAM_COMP_ARITH: cram_block_method = 6; +pub const cram_block_method_CRAM_COMP_FQZ: cram_block_method = 7; +pub const cram_block_method_CRAM_COMP_TOK3: cram_block_method = 8; +pub type cram_block_method = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_method_details { + pub method: cram_block_method, + pub level: ::std::os::raw::c_int, + pub order: ::std::os::raw::c_int, + pub rle: ::std::os::raw::c_int, + pub pack: ::std::os::raw::c_int, + pub stripe: ::std::os::raw::c_int, + pub cat: ::std::os::raw::c_int, + pub nosz: ::std::os::raw::c_int, + pub Nway: ::std::os::raw::c_int, + pub ext: ::std::os::raw::c_int, +} +pub const cram_content_type_CT_ERROR: cram_content_type = -1; +pub const cram_content_type_FILE_HEADER: cram_content_type = 0; +pub const cram_content_type_COMPRESSION_HEADER: cram_content_type = 1; +pub const cram_content_type_MAPPED_SLICE: cram_content_type = 2; +pub const cram_content_type_UNMAPPED_SLICE: cram_content_type = 3; +pub const cram_content_type_EXTERNAL: cram_content_type = 4; +pub const cram_content_type_CORE: cram_content_type = 5; +pub type cram_content_type = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_file_def { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_container { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_block { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_slice { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_metrics { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_block_slice_hdr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_block_compression_hdr { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_codec { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct refs_t { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn cram_fd_get_header(fd: *mut cram_fd) -> *mut sam_hdr_t; +} +unsafe extern "C" { + pub fn cram_fd_set_header(fd: *mut cram_fd, hdr: *mut sam_hdr_t); +} +unsafe extern "C" { + pub fn cram_fd_get_version(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_fd_set_version(fd: *mut cram_fd, vers: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn cram_major_vers(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_minor_vers(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_fd_get_fp(fd: *mut cram_fd) -> *mut hFILE; +} +unsafe extern "C" { + pub fn cram_fd_set_fp(fd: *mut cram_fd, fp: *mut hFILE); +} +unsafe extern "C" { + pub fn cram_container_get_length(c: *mut cram_container) -> i32; +} +unsafe extern "C" { + pub fn cram_container_set_length(c: *mut cram_container, length: i32); +} +unsafe extern "C" { + pub fn cram_container_get_num_blocks(c: *mut cram_container) -> i32; +} +unsafe extern "C" { + pub fn cram_container_set_num_blocks(c: *mut cram_container, num_blocks: i32); +} +unsafe extern "C" { + pub fn cram_container_get_landmarks( + c: *mut cram_container, + num_landmarks: *mut i32, + ) -> *mut i32; +} +unsafe extern "C" { + pub fn cram_container_set_landmarks( + c: *mut cram_container, + num_landmarks: i32, + landmarks: *mut i32, + ); +} +unsafe extern "C" { + pub fn cram_container_get_num_records(c: *mut cram_container) -> i32; +} +unsafe extern "C" { + pub fn cram_container_get_num_bases(c: *mut cram_container) -> i64; +} +unsafe extern "C" { + pub fn cram_container_is_empty(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_block_get_content_id(b: *mut cram_block) -> i32; +} +unsafe extern "C" { + pub fn cram_block_get_comp_size(b: *mut cram_block) -> i32; +} +unsafe extern "C" { + pub fn cram_block_get_uncomp_size(b: *mut cram_block) -> i32; +} +unsafe extern "C" { + pub fn cram_block_get_crc32(b: *mut cram_block) -> i32; +} +unsafe extern "C" { + pub fn cram_block_get_data(b: *mut cram_block) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn cram_block_get_content_type(b: *mut cram_block) -> cram_content_type; +} +unsafe extern "C" { + pub fn cram_block_get_method(b: *mut cram_block) -> cram_block_method; +} +unsafe extern "C" { + pub fn cram_expand_method( + data: *mut u8, + size: i32, + comp: cram_block_method, + ) -> *mut cram_method_details; +} +unsafe extern "C" { + pub fn cram_block_set_content_id(b: *mut cram_block, id: i32); +} +unsafe extern "C" { + pub fn cram_block_set_comp_size(b: *mut cram_block, size: i32); +} +unsafe extern "C" { + pub fn cram_block_set_uncomp_size(b: *mut cram_block, size: i32); +} +unsafe extern "C" { + pub fn cram_block_set_crc32(b: *mut cram_block, crc: i32); +} +unsafe extern "C" { + pub fn cram_block_set_data(b: *mut cram_block, data: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn cram_block_append( + b: *mut cram_block, + data: *const ::std::os::raw::c_void, + size: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_block_update_size(b: *mut cram_block); +} +unsafe extern "C" { + pub fn cram_block_get_offset(b: *mut cram_block) -> usize; +} +unsafe extern "C" { + pub fn cram_block_set_offset(b: *mut cram_block, offset: usize); +} +unsafe extern "C" { + pub fn cram_block_size(b: *mut cram_block) -> u32; +} +unsafe extern "C" { + pub fn cram_codec_get_content_ids(c: *mut cram_codec, ids: *mut ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn cram_codec_describe(c: *mut cram_codec, ks: *mut kstring_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_transcode_rg( + in_: *mut cram_fd, + out: *mut cram_fd, + c: *mut cram_container, + nrg: ::std::os::raw::c_int, + in_rg: *mut ::std::os::raw::c_int, + out_rg: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_copy_slice( + in_: *mut cram_fd, + out: *mut cram_fd, + num_slice: i32, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_decode_compression_header( + fd: *mut cram_fd, + b: *mut cram_block, + ) -> *mut cram_block_compression_hdr; +} +unsafe extern "C" { + pub fn cram_free_compression_header(hdr: *mut cram_block_compression_hdr); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cram_cid2ds_t { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn cram_update_cid2ds_map( + hdr: *mut cram_block_compression_hdr, + cid2ds: *mut cram_cid2ds_t, + ) -> *mut cram_cid2ds_t; +} +unsafe extern "C" { + pub fn cram_cid2ds_query( + c2d: *mut cram_cid2ds_t, + content_id: ::std::os::raw::c_int, + n: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_cid2ds_free(cid2ds: *mut cram_cid2ds_t); +} +unsafe extern "C" { + pub fn cram_describe_encodings( + hdr: *mut cram_block_compression_hdr, + ks: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_slice_hdr_get_num_blocks(hdr: *mut cram_block_slice_hdr) -> i32; +} +unsafe extern "C" { + pub fn cram_slice_hdr_get_embed_ref_id(h: *mut cram_block_slice_hdr) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_slice_hdr_get_coords( + h: *mut cram_block_slice_hdr, + refid: *mut ::std::os::raw::c_int, + start: *mut hts_pos_t, + span: *mut hts_pos_t, + ); +} +unsafe extern "C" { + pub fn cram_decode_slice_header( + fd: *mut cram_fd, + b: *mut cram_block, + ) -> *mut cram_block_slice_hdr; +} +unsafe extern "C" { + pub fn cram_free_slice_header(hdr: *mut cram_block_slice_hdr); +} +unsafe extern "C" { + pub fn cram_new_block( + content_type: cram_content_type, + content_id: ::std::os::raw::c_int, + ) -> *mut cram_block; +} +unsafe extern "C" { + pub fn cram_read_block(fd: *mut cram_fd) -> *mut cram_block; +} +unsafe extern "C" { + pub fn cram_write_block(fd: *mut cram_fd, b: *mut cram_block) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_free_block(b: *mut cram_block); +} +unsafe extern "C" { + pub fn cram_uncompress_block(b: *mut cram_block) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_compress_block( + fd: *mut cram_fd, + b: *mut cram_block, + metrics: *mut cram_metrics, + method: ::std::os::raw::c_int, + level: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_compress_block2( + fd: *mut cram_fd, + s: *mut cram_slice, + b: *mut cram_block, + metrics: *mut cram_metrics, + method: ::std::os::raw::c_int, + level: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_new_container( + nrec: ::std::os::raw::c_int, + nslice: ::std::os::raw::c_int, + ) -> *mut cram_container; +} +unsafe extern "C" { + pub fn cram_free_container(c: *mut cram_container); +} +unsafe extern "C" { + pub fn cram_read_container(fd: *mut cram_fd) -> *mut cram_container; +} +unsafe extern "C" { + pub fn cram_write_container(fd: *mut cram_fd, h: *mut cram_container) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_store_container( + fd: *mut cram_fd, + c: *mut cram_container, + dat: *mut ::std::os::raw::c_char, + size: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_container_size(c: *mut cram_container) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_open( + filename: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut cram_fd; +} +unsafe extern "C" { + pub fn cram_dopen( + fp: *mut hFILE, + filename: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut cram_fd; +} +unsafe extern "C" { + pub fn cram_close(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_seek( + fd: *mut cram_fd, + offset: off_t, + whence: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_flush(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_eof(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_set_option(fd: *mut cram_fd, opt: hts_fmt_option, ...) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_set_voption( + fd: *mut cram_fd, + opt: hts_fmt_option, + args: va_list, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_set_header(fd: *mut cram_fd, hdr: *mut sam_hdr_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn cram_check_EOF(fd: *mut cram_fd) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn int32_put_blk(b: *mut cram_block, val: i32) -> ::std::os::raw::c_int; +} +pub type SAM_hdr = sam_hdr_t; +unsafe extern "C" { + pub fn cram_get_refs(fd: *mut htsFile) -> *mut refs_t; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bgzf_mtaux_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bgzidx_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bgzf_cache_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct z_stream_s { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct BGZF { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub cache_size: ::std::os::raw::c_int, + pub block_length: ::std::os::raw::c_int, + pub block_clength: ::std::os::raw::c_int, + pub block_offset: ::std::os::raw::c_int, + pub block_address: i64, + pub uncompressed_address: i64, + pub uncompressed_block: *mut ::std::os::raw::c_void, + pub compressed_block: *mut ::std::os::raw::c_void, + pub cache: *mut bgzf_cache_t, + pub fp: *mut hFILE, + pub mt: *mut bgzf_mtaux_t, + pub idx: *mut bgzidx_t, + pub idx_build_otf: ::std::os::raw::c_int, + pub gz_stream: *mut z_stream_s, + pub seeked: i64, +} +impl BGZF { + #[inline] + pub fn errcode(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) } + } + #[inline] + pub fn set_errcode(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 16u8, val as u64) + } + } + #[inline] + pub unsafe fn errcode_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_errcode_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] + pub fn reserved(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_reserved(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn reserved_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_reserved_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 16usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_write(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_write(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_write_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 17usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_write_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 17usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn no_eof_block(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_eof_block(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn no_eof_block_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 18usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_no_eof_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 18usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_be(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_be(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_be_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 19usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_be_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 19usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn compress_level(&self) -> ::std::os::raw::c_int { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 9u8) as u32) } + } + #[inline] + pub fn set_compress_level(&mut self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 9u8, val as u64) + } + } + #[inline] + pub unsafe fn compress_level_raw(this: *const Self) -> ::std::os::raw::c_int { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 20usize, + 9u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_compress_level_raw(this: *mut Self, val: ::std::os::raw::c_int) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 20usize, + 9u8, + val as u64, + ) + } + } + #[inline] + pub fn last_block_eof(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_last_block_eof(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn last_block_eof_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_last_block_eof_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 29usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_compressed(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_compressed(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_compressed_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 30usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_compressed_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 30usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn is_gzip(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_gzip(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub unsafe fn is_gzip_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_is_gzip_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] + pub fn new_bitfield_1( + errcode: ::std::os::raw::c_uint, + reserved: ::std::os::raw::c_uint, + is_write: ::std::os::raw::c_uint, + no_eof_block: ::std::os::raw::c_uint, + is_be: ::std::os::raw::c_uint, + compress_level: ::std::os::raw::c_int, + last_block_eof: ::std::os::raw::c_uint, + is_compressed: ::std::os::raw::c_uint, + is_gzip: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 16u8, { + let errcode: u32 = unsafe { ::std::mem::transmute(errcode) }; + errcode as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let reserved: u32 = unsafe { ::std::mem::transmute(reserved) }; + reserved as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let is_write: u32 = unsafe { ::std::mem::transmute(is_write) }; + is_write as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let no_eof_block: u32 = unsafe { ::std::mem::transmute(no_eof_block) }; + no_eof_block as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let is_be: u32 = unsafe { ::std::mem::transmute(is_be) }; + is_be as u64 + }); + __bindgen_bitfield_unit.set(20usize, 9u8, { + let compress_level: u32 = unsafe { ::std::mem::transmute(compress_level) }; + compress_level as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let last_block_eof: u32 = unsafe { ::std::mem::transmute(last_block_eof) }; + last_block_eof as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let is_compressed: u32 = unsafe { ::std::mem::transmute(is_compressed) }; + is_compressed as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let is_gzip: u32 = unsafe { ::std::mem::transmute(is_gzip) }; + is_gzip as u64 + }); + __bindgen_bitfield_unit + } +} +unsafe extern "C" { + pub fn bgzf_dopen(fd: ::std::os::raw::c_int, mode: *const ::std::os::raw::c_char) -> *mut BGZF; +} +unsafe extern "C" { + pub fn bgzf_open( + path: *const ::std::os::raw::c_char, + mode: *const ::std::os::raw::c_char, + ) -> *mut BGZF; +} +unsafe extern "C" { + pub fn bgzf_hopen(fp: *mut hFILE, mode: *const ::std::os::raw::c_char) -> *mut BGZF; +} +unsafe extern "C" { + pub fn bgzf_close(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_read(fp: *mut BGZF, data: *mut ::std::os::raw::c_void, length: usize) -> isize; +} +unsafe extern "C" { + pub fn bgzf_write(fp: *mut BGZF, data: *const ::std::os::raw::c_void, length: usize) -> isize; +} +unsafe extern "C" { + pub fn bgzf_block_write( + fp: *mut BGZF, + data: *const ::std::os::raw::c_void, + length: usize, + ) -> isize; +} +unsafe extern "C" { + pub fn bgzf_peek(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_raw_read(fp: *mut BGZF, data: *mut ::std::os::raw::c_void, length: usize) -> isize; +} +unsafe extern "C" { + pub fn bgzf_raw_write( + fp: *mut BGZF, + data: *const ::std::os::raw::c_void, + length: usize, + ) -> isize; +} +unsafe extern "C" { + pub fn bgzf_flush(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_seek(fp: *mut BGZF, pos: i64, whence: ::std::os::raw::c_int) -> i64; +} +unsafe extern "C" { + pub fn bgzf_check_EOF(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_compression(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_is_bgzf(fn_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_set_cache_size(fp: *mut BGZF, size: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn bgzf_flush_try(fp: *mut BGZF, size: isize) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_getc(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_getline( + fp: *mut BGZF, + delim: ::std::os::raw::c_int, + str_: *mut kstring_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_read_block(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_thread_pool( + fp: *mut BGZF, + pool: *mut hts_tpool, + qsize: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_mt( + fp: *mut BGZF, + n_threads: ::std::os::raw::c_int, + n_sub_blks: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_compress( + dst: *mut ::std::os::raw::c_void, + dlen: *mut usize, + src: *const ::std::os::raw::c_void, + slen: usize, + level: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_useek( + fp: *mut BGZF, + uoffset: off_t, + where_: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_utell(fp: *mut BGZF) -> off_t; +} +unsafe extern "C" { + pub fn bgzf_index_build_init(fp: *mut BGZF) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_index_load( + fp: *mut BGZF, + bname: *const ::std::os::raw::c_char, + suffix: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_index_load_hfile( + fp: *mut BGZF, + idx: *mut hFILE, + name: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_index_dump( + fp: *mut BGZF, + bname: *const ::std::os::raw::c_char, + suffix: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bgzf_index_dump_hfile( + fp: *mut BGZF, + idx: *mut hFILE, + name: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_trim_alleles(header: *const bcf_hdr_t, line: *mut bcf1_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_remove_alleles( + header: *const bcf_hdr_t, + line: *mut bcf1_t, + mask: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_remove_allele_set( + header: *const bcf_hdr_t, + line: *mut bcf1_t, + rm_set: *const kbitset_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_calc_ac( + header: *const bcf_hdr_t, + line: *mut bcf1_t, + ac: *mut ::std::os::raw::c_int, + which: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_gt_type( + fmt_ptr: *mut bcf_fmt_t, + isample: ::std::os::raw::c_int, + ial: *mut ::std::os::raw::c_int, + jal: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tbx_conf_t { + pub preset: i32, + pub sc: i32, + pub bc: i32, + pub ec: i32, + pub meta_char: i32, + pub line_skip: i32, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tbx_t { + pub conf: tbx_conf_t, + pub idx: *mut hts_idx_t, + pub dict: *mut ::std::os::raw::c_void, +} +unsafe extern "C" { + pub static tbx_conf_gff: tbx_conf_t; +} +unsafe extern "C" { + pub static tbx_conf_bed: tbx_conf_t; +} +unsafe extern "C" { + pub static tbx_conf_psltbl: tbx_conf_t; +} +unsafe extern "C" { + pub static tbx_conf_sam: tbx_conf_t; +} +unsafe extern "C" { + pub static tbx_conf_vcf: tbx_conf_t; +} +unsafe extern "C" { + pub fn tbx_name2id(tbx: *mut tbx_t, ss: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_get_bgzfp(fp: *mut htsFile) -> *mut BGZF; +} +unsafe extern "C" { + pub fn tbx_readrec( + fp: *mut BGZF, + tbxv: *mut ::std::os::raw::c_void, + sv: *mut ::std::os::raw::c_void, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tbx_index( + fp: *mut BGZF, + min_shift: ::std::os::raw::c_int, + conf: *const tbx_conf_t, + ) -> *mut tbx_t; +} +unsafe extern "C" { + pub fn tbx_index_build( + fn_: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + conf: *const tbx_conf_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tbx_index_build2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + conf: *const tbx_conf_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tbx_index_build3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + min_shift: ::std::os::raw::c_int, + n_threads: ::std::os::raw::c_int, + conf: *const tbx_conf_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn tbx_index_load(fn_: *const ::std::os::raw::c_char) -> *mut tbx_t; +} +unsafe extern "C" { + pub fn tbx_index_load2( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + ) -> *mut tbx_t; +} +unsafe extern "C" { + pub fn tbx_index_load3( + fn_: *const ::std::os::raw::c_char, + fnidx: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + ) -> *mut tbx_t; +} +unsafe extern "C" { + pub fn tbx_seqnames( + tbx: *mut tbx_t, + n: *mut ::std::os::raw::c_int, + ) -> *mut *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn tbx_destroy(tbx: *mut tbx_t); +} +pub const bcf_sr_opt_t_BCF_SR_REQUIRE_IDX: bcf_sr_opt_t = 0; +pub const bcf_sr_opt_t_BCF_SR_PAIR_LOGIC: bcf_sr_opt_t = 1; +pub const bcf_sr_opt_t_BCF_SR_ALLOW_NO_IDX: bcf_sr_opt_t = 2; +pub const bcf_sr_opt_t_BCF_SR_REGIONS_OVERLAP: bcf_sr_opt_t = 3; +pub const bcf_sr_opt_t_BCF_SR_TARGETS_OVERLAP: bcf_sr_opt_t = 4; +pub type bcf_sr_opt_t = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_sr_region_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_sr_regions_t { + pub tbx: *mut tbx_t, + pub itr: *mut hts_itr_t, + pub line: kstring_t, + pub file: *mut htsFile, + pub fname: *mut ::std::os::raw::c_char, + pub is_bin: ::std::os::raw::c_int, + pub als: *mut *mut ::std::os::raw::c_char, + pub als_str: kstring_t, + pub nals: ::std::os::raw::c_int, + pub mals: ::std::os::raw::c_int, + pub als_type: ::std::os::raw::c_int, + pub missed_reg_handler: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut bcf_sr_regions_t, arg2: *mut ::std::os::raw::c_void), + >, + pub missed_reg_data: *mut ::std::os::raw::c_void, + pub regs: *mut bcf_sr_region_t, + pub seq_hash: *mut ::std::os::raw::c_void, + pub seq_names: *mut *mut ::std::os::raw::c_char, + pub nseqs: ::std::os::raw::c_int, + pub iseq: ::std::os::raw::c_int, + pub start: hts_pos_t, + pub end: hts_pos_t, + pub prev_seq: ::std::os::raw::c_int, + pub prev_start: hts_pos_t, + pub prev_end: hts_pos_t, + pub overlap: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_sr_t { + pub file: *mut htsFile, + pub tbx_idx: *mut tbx_t, + pub bcf_idx: *mut hts_idx_t, + pub header: *mut bcf_hdr_t, + pub itr: *mut hts_itr_t, + pub fname: *mut ::std::os::raw::c_char, + pub buffer: *mut *mut bcf1_t, + pub nbuffer: ::std::os::raw::c_int, + pub mbuffer: ::std::os::raw::c_int, + pub nfilter_ids: ::std::os::raw::c_int, + pub filter_ids: *mut ::std::os::raw::c_int, + pub samples: *mut ::std::os::raw::c_int, + pub n_smpl: ::std::os::raw::c_int, +} +pub const bcf_sr_error_open_failed: bcf_sr_error = 0; +pub const bcf_sr_error_not_bgzf: bcf_sr_error = 1; +pub const bcf_sr_error_idx_load_failed: bcf_sr_error = 2; +pub const bcf_sr_error_file_type_error: bcf_sr_error = 3; +pub const bcf_sr_error_api_usage_error: bcf_sr_error = 4; +pub const bcf_sr_error_header_error: bcf_sr_error = 5; +pub const bcf_sr_error_no_eof: bcf_sr_error = 6; +pub const bcf_sr_error_no_memory: bcf_sr_error = 7; +pub const bcf_sr_error_vcf_parse_error: bcf_sr_error = 8; +pub const bcf_sr_error_bcf_read_error: bcf_sr_error = 9; +pub const bcf_sr_error_noidx_error: bcf_sr_error = 10; +pub type bcf_sr_error = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct bcf_srs_t { + pub collapse: ::std::os::raw::c_int, + pub apply_filters: *mut ::std::os::raw::c_char, + pub require_index: ::std::os::raw::c_int, + pub max_unpack: ::std::os::raw::c_int, + pub has_line: *mut ::std::os::raw::c_int, + pub errnum: bcf_sr_error, + pub readers: *mut bcf_sr_t, + pub nreaders: ::std::os::raw::c_int, + pub streaming: ::std::os::raw::c_int, + pub explicit_regs: ::std::os::raw::c_int, + pub samples: *mut *mut ::std::os::raw::c_char, + pub regions: *mut bcf_sr_regions_t, + pub targets: *mut bcf_sr_regions_t, + pub targets_als: ::std::os::raw::c_int, + pub targets_exclude: ::std::os::raw::c_int, + pub tmps: kstring_t, + pub n_smpl: ::std::os::raw::c_int, + pub n_threads: ::std::os::raw::c_int, + pub p: *mut htsThreadPool, + pub aux: *mut ::std::os::raw::c_void, +} +unsafe extern "C" { + pub fn bcf_sr_init() -> *mut bcf_srs_t; +} +unsafe extern "C" { + pub fn bcf_sr_destroy(readers: *mut bcf_srs_t); +} +unsafe extern "C" { + pub fn bcf_sr_strerror(errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bcf_sr_set_opt(readers: *mut bcf_srs_t, opt: bcf_sr_opt_t, ...) + -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_set_threads( + files: *mut bcf_srs_t, + n_threads: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_destroy_threads(files: *mut bcf_srs_t); +} +unsafe extern "C" { + pub fn bcf_sr_add_reader( + readers: *mut bcf_srs_t, + fname: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_remove_reader(files: *mut bcf_srs_t, i: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn bcf_sr_next_line(readers: *mut bcf_srs_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_seek( + readers: *mut bcf_srs_t, + seq: *const ::std::os::raw::c_char, + pos: hts_pos_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_set_samples( + readers: *mut bcf_srs_t, + samples: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_set_targets( + readers: *mut bcf_srs_t, + targets: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + alleles: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_set_regions( + readers: *mut bcf_srs_t, + regions: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_regions_init( + regions: *const ::std::os::raw::c_char, + is_file: ::std::os::raw::c_int, + chr: ::std::os::raw::c_int, + from: ::std::os::raw::c_int, + to: ::std::os::raw::c_int, + ) -> *mut bcf_sr_regions_t; +} +unsafe extern "C" { + pub fn bcf_sr_regions_destroy(regions: *mut bcf_sr_regions_t); +} +unsafe extern "C" { + pub fn bcf_sr_regions_seek( + regions: *mut bcf_sr_regions_t, + chr: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_regions_next(reg: *mut bcf_sr_regions_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_regions_overlap( + reg: *mut bcf_sr_regions_t, + seq: *const ::std::os::raw::c_char, + start: hts_pos_t, + end: hts_pos_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcf_sr_regions_flush(regs: *mut bcf_sr_regions_t) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct kbitset_t { + pub n: usize, + pub n_max: usize, + pub b: [::std::os::raw::c_ulong; 1usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct kbitset_iter_t { + pub mask: ::std::os::raw::c_ulong, + pub elt: usize, + pub i: ::std::os::raw::c_int, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct faidx_t { + _unused: [u8; 0], +} +pub const fai_format_options_FAI_NONE: fai_format_options = 0; +pub const fai_format_options_FAI_FASTA: fai_format_options = 1; +pub const fai_format_options_FAI_FASTQ: fai_format_options = 2; +pub type fai_format_options = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn fai_build3( + fn_: *const ::std::os::raw::c_char, + fnfai: *const ::std::os::raw::c_char, + fngzi: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fai_build(fn_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fai_destroy(fai: *mut faidx_t); +} +pub const fai_load_options_FAI_CREATE: fai_load_options = 1; +pub type fai_load_options = ::std::os::raw::c_uint; +unsafe extern "C" { + pub fn fai_load3( + fn_: *const ::std::os::raw::c_char, + fnfai: *const ::std::os::raw::c_char, + fngzi: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + ) -> *mut faidx_t; +} +unsafe extern "C" { + pub fn fai_load(fn_: *const ::std::os::raw::c_char) -> *mut faidx_t; +} +unsafe extern "C" { + pub fn fai_load3_format( + fn_: *const ::std::os::raw::c_char, + fnfai: *const ::std::os::raw::c_char, + fngzi: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + format: fai_format_options, + ) -> *mut faidx_t; +} +unsafe extern "C" { + pub fn fai_load_format( + fn_: *const ::std::os::raw::c_char, + format: fai_format_options, + ) -> *mut faidx_t; +} +unsafe extern "C" { + pub fn fai_fetch( + fai: *const faidx_t, + reg: *const ::std::os::raw::c_char, + len: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fai_fetch64( + fai: *const faidx_t, + reg: *const ::std::os::raw::c_char, + len: *mut hts_pos_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fai_line_length(fai: *const faidx_t, reg: *const ::std::os::raw::c_char) -> hts_pos_t; +} +unsafe extern "C" { + pub fn fai_fetchqual( + fai: *const faidx_t, + reg: *const ::std::os::raw::c_char, + len: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fai_fetchqual64( + fai: *const faidx_t, + reg: *const ::std::os::raw::c_char, + len: *mut hts_pos_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_fetch_nseq(fai: *const faidx_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn faidx_fetch_seq( + fai: *const faidx_t, + c_name: *const ::std::os::raw::c_char, + p_beg_i: ::std::os::raw::c_int, + p_end_i: ::std::os::raw::c_int, + len: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_fetch_seq64( + fai: *const faidx_t, + c_name: *const ::std::os::raw::c_char, + p_beg_i: hts_pos_t, + p_end_i: hts_pos_t, + len: *mut hts_pos_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_fetch_qual( + fai: *const faidx_t, + c_name: *const ::std::os::raw::c_char, + p_beg_i: ::std::os::raw::c_int, + p_end_i: ::std::os::raw::c_int, + len: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_fetch_qual64( + fai: *const faidx_t, + c_name: *const ::std::os::raw::c_char, + p_beg_i: hts_pos_t, + p_end_i: hts_pos_t, + len: *mut hts_pos_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_has_seq( + fai: *const faidx_t, + seq: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn faidx_nseq(fai: *const faidx_t) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn faidx_iseq( + fai: *const faidx_t, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn faidx_seq_len64(fai: *const faidx_t, seq: *const ::std::os::raw::c_char) -> hts_pos_t; +} +unsafe extern "C" { + pub fn faidx_seq_len( + fai: *const faidx_t, + seq: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fai_parse_region( + fai: *const faidx_t, + s: *const ::std::os::raw::c_char, + tid: *mut ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + flags: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn fai_adjust_region( + fai: *const faidx_t, + tid: ::std::os::raw::c_int, + beg: *mut hts_pos_t, + end: *mut hts_pos_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fai_set_cache_size(fai: *mut faidx_t, cache_size: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn fai_thread_pool( + fai: *mut faidx_t, + pool: *mut hts_tpool, + qsize: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn fai_path(fa: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_tpool_process { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hts_tpool_result { + _unused: [u8; 0], +} +unsafe extern "C" { + pub fn hts_tpool_init(n: ::std::os::raw::c_int) -> *mut hts_tpool; +} +unsafe extern "C" { + pub fn hts_tpool_size(p: *mut hts_tpool) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_dispatch( + p: *mut hts_tpool, + q: *mut hts_tpool_process, + func: ::std::option::Option< + unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void, + >, + arg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_dispatch2( + p: *mut hts_tpool, + q: *mut hts_tpool_process, + func: ::std::option::Option< + unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void, + >, + arg: *mut ::std::os::raw::c_void, + nonblock: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_dispatch3( + p: *mut hts_tpool, + q: *mut hts_tpool_process, + exec_func: ::std::option::Option< + unsafe extern "C" fn(arg: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void, + >, + arg: *mut ::std::os::raw::c_void, + job_cleanup: ::std::option::Option, + result_cleanup: ::std::option::Option< + unsafe extern "C" fn(data: *mut ::std::os::raw::c_void), + >, + nonblock: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_wake_dispatch(q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_flush(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_reset( + q: *mut hts_tpool_process, + free_results: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_qsize(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_destroy(p: *mut hts_tpool); +} +unsafe extern "C" { + pub fn hts_tpool_kill(p: *mut hts_tpool); +} +unsafe extern "C" { + pub fn hts_tpool_next_result(q: *mut hts_tpool_process) -> *mut hts_tpool_result; +} +unsafe extern "C" { + pub fn hts_tpool_next_result_wait(q: *mut hts_tpool_process) -> *mut hts_tpool_result; +} +unsafe extern "C" { + pub fn hts_tpool_delete_result(r: *mut hts_tpool_result, free_data: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn hts_tpool_result_data(r: *mut hts_tpool_result) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn hts_tpool_process_init( + p: *mut hts_tpool, + qsize: ::std::os::raw::c_int, + in_only: ::std::os::raw::c_int, + ) -> *mut hts_tpool_process; +} +unsafe extern "C" { + pub fn hts_tpool_process_destroy(q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_empty(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_len(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_sz(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_shutdown(q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_is_shutdown(q: *mut hts_tpool_process) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn hts_tpool_process_attach(p: *mut hts_tpool, q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_detach(p: *mut hts_tpool, q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_ref_incr(q: *mut hts_tpool_process); +} +unsafe extern "C" { + pub fn hts_tpool_process_ref_decr(q: *mut hts_tpool_process); +} +unsafe extern "C" { + #[link_name = "\u{1}wrap_kbs_init2"] + pub fn kbs_init2(ni: usize, fill: ::std::os::raw::c_int) -> *mut kbitset_t; +} +unsafe extern "C" { + #[link_name = "\u{1}wrap_kbs_init"] + pub fn kbs_init(ni: usize) -> *mut kbitset_t; +} +unsafe extern "C" { + #[link_name = "\u{1}wrap_kbs_insert"] + pub fn kbs_insert(bs: *mut kbitset_t, i: ::std::os::raw::c_int); +} +unsafe extern "C" { + #[link_name = "\u{1}wrap_kbs_destroy"] + pub fn kbs_destroy(bs: *mut kbitset_t); +} +pub type __builtin_va_list = *mut ::std::os::raw::c_char;