From e6b91179a90f3454fcb4feb630300f1a5c2c87b2 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 13:51:26 +0200 Subject: [PATCH 01/10] uses default shell here too --- build-sequoia-iOS.sh | 2 -- 1 file changed, 2 deletions(-) diff --git a/build-sequoia-iOS.sh b/build-sequoia-iOS.sh index 14297b3..ff567d5 100644 --- a/build-sequoia-iOS.sh +++ b/build-sequoia-iOS.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for iOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. set -e From c407851025cdeb9fc7020f2d6b8b7ae2220d7e34 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 13:55:43 +0200 Subject: [PATCH 02/10] uses default shell everywhere now --- build-asn1executable.sh | 3 --- build-fat-bins.sh | 2 -- build-fat-libs.sh | 2 -- build-macOSAdapter.sh | 2 -- build-macos_dependency.template | 2 -- build-pEpEngine-macOS.sh | 2 -- build-sequoia-macOS.sh | 2 -- generate_and_run_mac_dependency_build_script.sh | 2 -- 8 files changed, 17 deletions(-) diff --git a/build-asn1executable.sh b/build-asn1executable.sh index 62b3e9f..d5e0369 100644 --- a/build-asn1executable.sh +++ b/build-asn1executable.sh @@ -1,6 +1,3 @@ - -#!/bin/bash - # Pass PREFIX as argument. If not passed, "local/" is used as deafult. # Exit on errors diff --git a/build-fat-bins.sh b/build-fat-bins.sh index b4d68d3..5184b00 100644 --- a/build-fat-bins.sh +++ b/build-fat-bins.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Creates fat libs of all .a files in `ARCH1_DIR` (1st param), combining .a with same name in `ARCH2_DIR` (2nd param), saving fat lib in `OUTPUT_DIR` (3rd param). # Exit on errors diff --git a/build-fat-libs.sh b/build-fat-libs.sh index 03cc937..4f43c8a 100644 --- a/build-fat-libs.sh +++ b/build-fat-libs.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Creates fat libs of all .a files in `ARCH1_DIR` (1st param), combining .a with same name in `ARCH2_DIR` (2nd param), saving fat lib in `OUTPUT_DIR` (3rd param). # Exit on errors diff --git a/build-macOSAdapter.sh b/build-macOSAdapter.sh index 29d9d13..308c8e8 100644 --- a/build-macOSAdapter.sh +++ b/build-macOSAdapter.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for macOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. Config can also be passed. # Sample: diff --git a/build-macos_dependency.template b/build-macos_dependency.template index c081d1d..1912766 100644 --- a/build-macos_dependency.template +++ b/build-macos_dependency.template @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for macOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. diff --git a/build-pEpEngine-macOS.sh b/build-pEpEngine-macOS.sh index 8db5f64..7effb33 100644 --- a/build-pEpEngine-macOS.sh +++ b/build-pEpEngine-macOS.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for macOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. Config can also be passed. # Sample: diff --git a/build-sequoia-macOS.sh b/build-sequoia-macOS.sh index 267f9b9..f94feca 100644 --- a/build-sequoia-macOS.sh +++ b/build-sequoia-macOS.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for macOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. set -e diff --git a/generate_and_run_mac_dependency_build_script.sh b/generate_and_run_mac_dependency_build_script.sh index 4c3cecf..7d3950c 100644 --- a/generate_and_run_mac_dependency_build_script.sh +++ b/generate_and_run_mac_dependency_build_script.sh @@ -1,5 +1,3 @@ -#!/bin/bash - # Builds fat lib for macOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. From 0a4b4416898150d1dcf4f78ff156b7c9b29f5546 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 16:30:12 +0200 Subject: [PATCH 03/10] IOS-2882 gpm iOS working --- .../project.pbxproj | 58 +++++++++++++ .../xcschemes/build_gmp_iOS.xcscheme | 67 +++++++++++++++ CommonPEPDependencies/config.plist | 2 + _config/pEp_versions.plist | 2 + build-ios_dependency.template | 85 +++++++++++++++++++ buildcode/gmp.code | 30 +++++++ ...ate_and_run_ios_dependency_build_script.sh | 46 ++++++++++ get-config-ios-deployment-target.sh | 12 +++ 8 files changed, 302 insertions(+) create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme create mode 100644 build-ios_dependency.template create mode 100644 buildcode/gmp.code create mode 100644 generate_and_run_ios_dependency_build_script.sh create mode 100755 get-config-ios-deployment-target.sh diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index 4142e44..3921586 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -18,6 +18,17 @@ name = CLEAN_ALL_iOS; productName = "libetpan-dependencies_macOS"; }; + 152E498D26A9B252009BD3CE /* build_gmp_iOS */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 152E498F26A9B252009BD3CE /* Build configuration list for PBXAggregateTarget "build_gmp_iOS" */; + buildPhases = ( + 152E498E26A9B252009BD3CE /* Build */, + ); + dependencies = ( + ); + name = build_gmp_iOS; + productName = "libetpan-dependencies_macOS"; + }; 1585EE16269DCEA600B822E1 /* build-pEpMIME-dependencies_macOS */ = { isa = PBXAggregateTarget; buildConfigurationList = 1585EE17269DCEA600B822E1 /* Build configuration list for PBXAggregateTarget "build-pEpMIME-dependencies_macOS" */; @@ -402,6 +413,7 @@ 1585F04A26A1D2BE00B822E1 /* build-pEp4ThunderbirdInstaller-dependencies_macOS */, 1585EEFC26A0432A00B822E1 /* CLEAN_ALL_macOS */, 1585F04126A1C14C00B822E1 /* CLEAN_PEP */, + 152E498D26A9B252009BD3CE /* build_gmp_iOS */, 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, 152E47C626A5B7C2009BD3CE /* CLEAN_ALL_iOS */, ); @@ -428,6 +440,25 @@ shellScript = "SCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/clean_all_iOS.sh\" \nsh \"${BUILD_SCRIPT}\" \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; + 152E498E26A9B252009BD3CE /* Build */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = Build; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = "/bin/sh -l"; + shellScript = "LIB_NAME=\"gmp\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; + showEnvVarsInLog = 0; + }; 1585EE28269DD87700B822E1 /* Build */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; @@ -803,6 +834,24 @@ }; name = Release; }; + 152E499026A9B252009BD3CE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 152E499126A9B252009BD3CE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; 1585EE0F269DC6DD00B822E1 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1151,6 +1200,15 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + 152E498F26A9B252009BD3CE /* Build configuration list for PBXAggregateTarget "build_gmp_iOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 152E499026A9B252009BD3CE /* Debug */, + 152E499126A9B252009BD3CE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; 1585EE0E269DC6DD00B822E1 /* Build configuration list for PBXProject "CommonPEPDependencies" */ = { isa = XCConfigurationList; buildConfigurations = ( diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme new file mode 100644 index 0000000..966b546 --- /dev/null +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CommonPEPDependencies/config.plist b/CommonPEPDependencies/config.plist index 8d9bac4..207fd53 100644 --- a/CommonPEPDependencies/config.plist +++ b/CommonPEPDependencies/config.plist @@ -2,6 +2,8 @@ + IOS_DEPLOYMENT + 12.0 MACOSX_DEPLOYMENT_x86_64 10.10 MACOSX_DEPLOYMENT_M1 diff --git a/_config/pEp_versions.plist b/_config/pEp_versions.plist index 028b32e..5e48b0b 100644 --- a/_config/pEp_versions.plist +++ b/_config/pEp_versions.plist @@ -2,6 +2,8 @@ + GMP_VERSION + 6.2.1 SEQUOIA_4_iOS_VERSION v2.1.6 SEQUOIA_4_MAC_OS_VERSION diff --git a/build-ios_dependency.template b/build-ios_dependency.template new file mode 100644 index 0000000..0bb42fa --- /dev/null +++ b/build-ios_dependency.template @@ -0,0 +1,85 @@ +# Builds fat lib for macOS (ARM64 & x86_64). +# Pass PREFIX as argument. If not passed, "local/" is used as deafult. + +# Exit on errors +set -e + +SCRIPT_DIR=$(dirname "$0") +PREFIX=$1 + +# Get Absolute Paths & Setup + +SCRIPT_DIR=$(dirname "$0") +pushd "${SCRIPT_DIR}" + SCRIPT_DIR=$(pwd) +popd +if [ "${PREFIX}" = "" ]; then + PREFIX="${SCRIPT_DIR}/local" +fi +mkdir -p "${PREFIX}" +pushd "${PREFIX}" + PREFIX=$(pwd) +popd + +TMP_DIR="${SCRIPT_DIR}/tmp" +INCLUDE_DIR="${PREFIX}/include" +LIB_DIR="${PREFIX}/lib" +BIN_DIR="${PREFIX}/bin" + +mkdir -p "${INCLUDE_DIR}" +mkdir -p "${LIB_DIR}" +mkdir -p "${TMP_DIR}" + + +IOS_DEPLOYMENT_TARGET=$(sh "${SCRIPT_DIR}"/get-config-ios-deployment-target.sh) + +# Funcs + +buildLib() +{ + ARCH=$1 + TARGET=$2 + HOST=$3 + SDK=$4 + SDK_PATH=`xcrun -sdk ${SDK} --show-sdk-path` + + CURRENT_LIB_DIR="${TMP_DIR}/${ARCH}" + mkdir -p "${CURRENT_LIB_DIR}/lib" + mkdir -p "${CURRENT_LIB_DIR}/include" + mkdir -p "${CURRENT_LIB_DIR}/bin" + + # START: Lib Specific Code + + BUILD_CODE + + # END: Lib Specific Code +} + +cleanup() +{ + rm -rf "${TMP_DIR}/x86_64" + rm -rf "${TMP_DIR}/arm64" +} + +# Setup + +cleanup + +mkdir -p "${TMP_DIR}" +mkdir -p "${PREFIX}" + +# Build +pushd "${TMP_DIR}" + buildLib "arm64" "aarch64-apple-ios" "aarch64-apple-darwin" "iphoneos" + buildLib "x86_64" "x86_64-apple-ios" "x86_64-apple-darwin" "iphonesimulator" +popd + +# Make Fat Lib +sh "${SCRIPT_DIR}/build-fat-libs.sh" "${TMP_DIR}/arm64/lib" "${TMP_DIR}/x86_64/lib" "${LIB_DIR}" + +# Copy Headers If Currently Building Lib +ARM64_INCLUDE_DIR="${TMP_DIR}/arm64/include" +cp -r "${ARM64_INCLUDE_DIR}"/* "${INCLUDE_DIR}" 2>/dev/null || : + +# Cleanup +cleanup diff --git a/buildcode/gmp.code b/buildcode/gmp.code new file mode 100644 index 0000000..96a2ab2 --- /dev/null +++ b/buildcode/gmp.code @@ -0,0 +1,30 @@ +GMP_VERSION=$(sh "${SCRIPT_DIR}"/get-pEp-version.sh "GMP_VERSION") +GMP_NAME="gmp-${GMP_VERSION}" + +OUTPUT_DIR=${SCRIPT_DIR}/build + +# Exit on errors +set -e + +if [ -f "${LIB_DIR}/libgmp.a" ]; then + echo "lib exists already in ${LIB_DIR}. If you want to rebuild it, delete the existing one." + exit 0 +fi + +GMP_DIR="${TMP_DIR}/${GMP_NAME}" +if [ ! -d "${GMP_DIR}" ]; then + # GMP snapshot must be used until released + wget -nc https://gmplib.org/download/gmp/$GMP_NAME.tar.bz2 + tar xvf ${GMP_NAME}.tar.bz2 +fi + +export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -miphoneos-version-min=${IOS_DEPLOYMENT_TARGET} -std=c99" +export LDFLAGS="-arch ${ARCH}" +export CC="$(xcrun --sdk ${SDK} -f clang) -arch ${ARCH} -isysroot ${SDK_PATH}" + +pushd gmp-$GMP_VERSION + PKG_CONFIG_ALLOW_CROSS=1 PKG_CONFIG_PATH=${CURRENT_LIB_DIR}/lib/pkgconfig ./configure --host=${HOST} --prefix=${CURRENT_LIB_DIR} --disable-assembly + make clean + make -j4 + make install +popd diff --git a/generate_and_run_ios_dependency_build_script.sh b/generate_and_run_ios_dependency_build_script.sh new file mode 100644 index 0000000..45aaf11 --- /dev/null +++ b/generate_and_run_ios_dependency_build_script.sh @@ -0,0 +1,46 @@ +# Builds fat lib for macOS (ARM64 & x86_64). +# Pass PREFIX as argument. If not passed, "local/" is used as deafult. + +# Exit on errors +set -e + +SCRIPT_DIR=$(dirname "$0") +LIB_NAME=$1 +PREFIX=$2 + +# Get Absolute Paths +pushd "${SCRIPT_DIR}" + SCRIPT_DIR=$(pwd) +popd +mkdir -p "${PREFIX}" +pushd "${PREFIX}" + PREFIX=$(pwd) +popd +GENERATED_SCRIPT="${SCRIPT_DIR}/generated.sh" + +exitAndPrintHelp() +{ + echo "Must be called passing \`LIB_NAME`\` (mandatory). \`PREFIX\` can also be passed (optional).\nSample:\n\`generate_and_run_ios_dependency_build_script \$LIB_NAME\`\n`generate_and_run_ios_dependency_build_script \$LIB_NAME \$PREFIX\`" + exit 1 +} + +if [ "${LIB_NAME}" = "" ]; then + exitAndPrintHelp +fi + +# Say Hello +echo "#####################################################" +echo "#Generating buildscript for ${LIB_NAME}" +echo "#####################################################" + +# Generate Actual Script + +BUILD_CODE_FILE="${SCRIPT_DIR}/buildcode/${LIB_NAME}.code" +BUILD_SCRIPT_TEMPLATE_FILE="${SCRIPT_DIR}/build-ios_dependency.template" +SEARCH_STRING="BUILD_CODE" +#Replaces ${SEARCH_STRING} in file ${BUILD_SCRIPT_TEMPLATE_FILE} with content of ${BUILD_CODE_FILE} +/opt/local/bin/gsed -e "/${SEARCH_STRING}/r ${BUILD_CODE_FILE}" -e "/${SEARCH_STRING}/d" ${BUILD_SCRIPT_TEMPLATE_FILE} > "${GENERATED_SCRIPT}" +sh ${GENERATED_SCRIPT} ${PREFIX} + +# Cleanup +rm -rf "${TMP_DIR}" diff --git a/get-config-ios-deployment-target.sh b/get-config-ios-deployment-target.sh new file mode 100755 index 0000000..ab24792 --- /dev/null +++ b/get-config-ios-deployment-target.sh @@ -0,0 +1,12 @@ +# returns the default IOS_DEPLOYMENT TARGET +SCRIPT_DIR=$(dirname $0) + +# Get Absolute Paths +pushd "${SCRIPT_DIR}" >/dev/null + SCRIPT_DIR=$(pwd) +popd >/dev/null + +CONFIG_PLIST="${SCRIPT_DIR}/CommonPEPDependencies/config.plist" +RESULT=$(/usr/libexec/PlistBuddy -c "Print IOS_DEPLOYMENT" "${CONFIG_PLIST}") + +echo ${RESULT} From af4e9d4728a6a26b19fdce0a07b7a28d8e230dc7 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 16:47:24 +0200 Subject: [PATCH 04/10] IOS-2882 gpm macOS working --- .../project.pbxproj | 71 +++++++++++++++++++ .../xcschemes/build_gmp_macOS.xcscheme | 67 +++++++++++++++++ buildcode/gmp.code | 4 +- 3 files changed, 141 insertions(+), 1 deletion(-) create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_macOS.xcscheme diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index 3921586..465a1e5 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -29,6 +29,17 @@ name = build_gmp_iOS; productName = "libetpan-dependencies_macOS"; }; + 152E499426A9B88E009BD3CE /* build_gmp_macOS */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 152E499626A9B88E009BD3CE /* Build configuration list for PBXAggregateTarget "build_gmp_macOS" */; + buildPhases = ( + 152E499526A9B88E009BD3CE /* Build */, + ); + dependencies = ( + ); + name = build_gmp_macOS; + productName = "libetpan-dependencies_macOS"; + }; 1585EE16269DCEA600B822E1 /* build-pEpMIME-dependencies_macOS */ = { isa = PBXAggregateTarget; buildConfigurationList = 1585EE17269DCEA600B822E1 /* Build configuration list for PBXAggregateTarget "build-pEpMIME-dependencies_macOS" */; @@ -200,6 +211,7 @@ 1585EF0626A0479800B822E1 /* Build */, ); dependencies = ( + 152E499326A9B88A009BD3CE /* PBXTargetDependency */, ); name = build_sequoia_iOS; productName = "libetpan-dependencies_macOS"; @@ -243,6 +255,13 @@ /* End PBXAggregateTarget section */ /* Begin PBXContainerItemProxy section */ + 152E499226A9B88A009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 152E498D26A9B252009BD3CE; + remoteInfo = build_gmp_iOS; + }; 1585EE35269EC8DD00B822E1 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; @@ -401,6 +420,7 @@ 1585EE3E269EC9BB00B822E1 /* build_openssl_macOS */, 1585EE48269ECB8700B822E1 /* build_cryptopp_macOS */, 1585EEA5269EDA1E00B822E1 /* build_asn1cexecutable */, + 152E499426A9B88E009BD3CE /* build_gmp_macOS */, 1585EECA269EF0F100B822E1 /* build_sequoia_macOS */, 1585EE43269ECB2500B822E1 /* build_pEpwebserver_macOS */, 1585EEAA269EDAE200B822E1 /* build_pEpengine_macOS */, @@ -459,6 +479,25 @@ shellScript = "LIB_NAME=\"gmp\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; + 152E499526A9B88E009BD3CE /* Build */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = Build; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = "/bin/sh -l"; + shellScript = "LIB_NAME=\"gmp\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_mac_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; + showEnvVarsInLog = 0; + }; 1585EE28269DD87700B822E1 /* Build */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; @@ -728,6 +767,11 @@ /* End PBXShellScriptBuildPhase section */ /* Begin PBXTargetDependency section */ + 152E499326A9B88A009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E498D26A9B252009BD3CE /* build_gmp_iOS */; + targetProxy = 152E499226A9B88A009BD3CE /* PBXContainerItemProxy */; + }; 1585EE36269EC8DD00B822E1 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 1585EE27269DD87700B822E1 /* build_libiconv_macOS */; @@ -852,6 +896,24 @@ }; name = Release; }; + 152E499726A9B88E009BD3CE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 152E499826A9B88E009BD3CE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; 1585EE0F269DC6DD00B822E1 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1209,6 +1271,15 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + 152E499626A9B88E009BD3CE /* Build configuration list for PBXAggregateTarget "build_gmp_macOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 152E499726A9B88E009BD3CE /* Debug */, + 152E499826A9B88E009BD3CE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; 1585EE0E269DC6DD00B822E1 /* Build configuration list for PBXProject "CommonPEPDependencies" */ = { isa = XCConfigurationList; buildConfigurations = ( diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_macOS.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_macOS.xcscheme new file mode 100644 index 0000000..9553dd9 --- /dev/null +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_macOS.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/buildcode/gmp.code b/buildcode/gmp.code index 96a2ab2..eb86451 100644 --- a/buildcode/gmp.code +++ b/buildcode/gmp.code @@ -18,7 +18,7 @@ if [ ! -d "${GMP_DIR}" ]; then tar xvf ${GMP_NAME}.tar.bz2 fi -export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -miphoneos-version-min=${IOS_DEPLOYMENT_TARGET} -std=c99" +export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99" export LDFLAGS="-arch ${ARCH}" export CC="$(xcrun --sdk ${SDK} -f clang) -arch ${ARCH} -isysroot ${SDK_PATH}" @@ -28,3 +28,5 @@ pushd gmp-$GMP_VERSION make -j4 make install popd + +rm -rf *.bz2 From c6b8d47cb35e3332423a4757ed0df8b341e7eab9 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 18:05:18 +0200 Subject: [PATCH 05/10] IOS-2882 build nettle 4 iOS works --- .../project.pbxproj | 71 +++++++++++++++++++ .../xcschemes/build_gmp_iOS.xcscheme | 4 +- .../xcschemes/build_gmp_macOS.xcscheme | 4 +- .../xcschemes/build_nettle_iOS.xcscheme | 67 +++++++++++++++++ _config/pEp_versions.plist | 2 + build-ios_dependency.template | 18 +++++ buildcode/gmp.code | 1 - buildcode/iconv.code | 1 - buildcode/nettle.code | 30 ++++++++ 9 files changed, 192 insertions(+), 6 deletions(-) create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_nettle_iOS.xcscheme create mode 100644 buildcode/nettle.code diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index 465a1e5..f66494e 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -40,6 +40,18 @@ name = build_gmp_macOS; productName = "libetpan-dependencies_macOS"; }; + 152E499926A9BC94009BD3CE /* build_nettle_iOS */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 152E499B26A9BC94009BD3CE /* Build configuration list for PBXAggregateTarget "build_nettle_iOS" */; + buildPhases = ( + 152E499A26A9BC94009BD3CE /* Build */, + ); + dependencies = ( + 152E499F26A9C62B009BD3CE /* PBXTargetDependency */, + ); + name = build_nettle_iOS; + productName = "libetpan-dependencies_macOS"; + }; 1585EE16269DCEA600B822E1 /* build-pEpMIME-dependencies_macOS */ = { isa = PBXAggregateTarget; buildConfigurationList = 1585EE17269DCEA600B822E1 /* Build configuration list for PBXAggregateTarget "build-pEpMIME-dependencies_macOS" */; @@ -262,6 +274,13 @@ remoteGlobalIDString = 152E498D26A9B252009BD3CE; remoteInfo = build_gmp_iOS; }; + 152E499E26A9C62B009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 152E498D26A9B252009BD3CE; + remoteInfo = build_gmp_iOS; + }; 1585EE35269EC8DD00B822E1 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; @@ -434,6 +453,7 @@ 1585EEFC26A0432A00B822E1 /* CLEAN_ALL_macOS */, 1585F04126A1C14C00B822E1 /* CLEAN_PEP */, 152E498D26A9B252009BD3CE /* build_gmp_iOS */, + 152E499926A9BC94009BD3CE /* build_nettle_iOS */, 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, 152E47C626A5B7C2009BD3CE /* CLEAN_ALL_iOS */, ); @@ -498,6 +518,25 @@ shellScript = "LIB_NAME=\"gmp\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_mac_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; + 152E499A26A9BC94009BD3CE /* Build */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = Build; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = "/bin/sh -l"; + shellScript = "LIB_NAME=\"nettle\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; + showEnvVarsInLog = 0; + }; 1585EE28269DD87700B822E1 /* Build */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; @@ -772,6 +811,11 @@ target = 152E498D26A9B252009BD3CE /* build_gmp_iOS */; targetProxy = 152E499226A9B88A009BD3CE /* PBXContainerItemProxy */; }; + 152E499F26A9C62B009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E498D26A9B252009BD3CE /* build_gmp_iOS */; + targetProxy = 152E499E26A9C62B009BD3CE /* PBXContainerItemProxy */; + }; 1585EE36269EC8DD00B822E1 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 1585EE27269DD87700B822E1 /* build_libiconv_macOS */; @@ -914,6 +958,24 @@ }; name = Release; }; + 152E499C26A9BC94009BD3CE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 152E499D26A9BC94009BD3CE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; 1585EE0F269DC6DD00B822E1 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1280,6 +1342,15 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + 152E499B26A9BC94009BD3CE /* Build configuration list for PBXAggregateTarget "build_nettle_iOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 152E499C26A9BC94009BD3CE /* Debug */, + 152E499D26A9BC94009BD3CE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; 1585EE0E269DC6DD00B822E1 /* Build configuration list for PBXProject "CommonPEPDependencies" */ = { isa = XCConfigurationList; buildConfigurations = ( diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme index 966b546..1a0c07a 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_gmp_iOS.xcscheme @@ -3,8 +3,8 @@ LastUpgradeVersion = "1250" version = "1.3"> + parallelizeBuildables = "NO" + buildImplicitDependencies = "NO"> + parallelizeBuildables = "NO" + buildImplicitDependencies = "NO"> + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/_config/pEp_versions.plist b/_config/pEp_versions.plist index 5e48b0b..5000060 100644 --- a/_config/pEp_versions.plist +++ b/_config/pEp_versions.plist @@ -2,6 +2,8 @@ + NETTLE_VERSION + 3.7.3 GMP_VERSION 6.2.1 SEQUOIA_4_iOS_VERSION diff --git a/build-ios_dependency.template b/build-ios_dependency.template index 0bb42fa..32c91b9 100644 --- a/build-ios_dependency.template +++ b/build-ios_dependency.template @@ -48,11 +48,29 @@ buildLib() mkdir -p "${CURRENT_LIB_DIR}/include" mkdir -p "${CURRENT_LIB_DIR}/bin" + # Set CFLAGS that fit most targets. Can be overrriden in .code file + if [[ $TARGET == *"ios"* ]]; then + export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99 -miphoneos-version-min=${IOS_DEPLOYMENT_TARGET}" + else + if [[ $ARCH == "arm64" ]]; then + export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99 -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET_ARM}" + elif [[ $ARCH == "x86_64" ]]; then + export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99 -mmacosx-version-min=${MACOSX_DEPLOYMENT_TARGET_INTEL}" + else + echo "Unhandled arch" + exit 1 + fi +fi + # START: Lib Specific Code BUILD_CODE # END: Lib Specific Code + + unset CFLAGS + unset LDFLAGS + unset CC } cleanup() diff --git a/buildcode/gmp.code b/buildcode/gmp.code index eb86451..ef0397c 100644 --- a/buildcode/gmp.code +++ b/buildcode/gmp.code @@ -18,7 +18,6 @@ if [ ! -d "${GMP_DIR}" ]; then tar xvf ${GMP_NAME}.tar.bz2 fi -export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99" export LDFLAGS="-arch ${ARCH}" export CC="$(xcrun --sdk ${SDK} -f clang) -arch ${ARCH} -isysroot ${SDK_PATH}" diff --git a/buildcode/iconv.code b/buildcode/iconv.code index 1c35e10..34a7fc6 100644 --- a/buildcode/iconv.code +++ b/buildcode/iconv.code @@ -8,7 +8,6 @@ if [ ! -d "${ICONV_DIR}" ]; then git clone -b "v1.16_without_lib_prefix_defines" https://gitea.pep.foundation/buff/libiconv.git fi pushd "${ICONV_DIR}" - export CFLAGS="-arch ${ARCH} -isysroot ${SDK_PATH} -std=c99" export LDFLAGS="-arch ${ARCH}" export CC="$(xcrun --sdk ${SDK} -f clang) -arch ${ARCH} -isysroot ${SDK_PATH}" diff --git a/buildcode/nettle.code b/buildcode/nettle.code new file mode 100644 index 0000000..ea16253 --- /dev/null +++ b/buildcode/nettle.code @@ -0,0 +1,30 @@ +NETTLE_VERSION=$(sh "${SCRIPT_DIR}"/get-pEp-version.sh "NETTLE_VERSION") +NETTLE_NAME="nettle-${NETTLE_VERSION}" + +OUTPUT_DIR=${SCRIPT_DIR}/build + +# Exit on errors +set -e + +if [ -f "${LIB_DIR}/libnettle.a" ]; then + echo "lib exists already in ${LIB_DIR}. If you want to rebuild it, delete the existing one." + exit 0 +fi + +GMP_DIR="${TMP_DIR}/${NETTLE_NAME}" +if [ ! -d "${GMP_DIR}" ]; then + wget -nc https://ftp.gnu.org/gnu/nettle/${NETTLE_NAME}.tar.gz + tar xvf ${NETTLE_NAME}.tar.gz +fi + +export LDFLAGS="-arch ${ARCH}" +export CC="$(xcrun --sdk ${SDK} -f clang) -arch ${ARCH} -isysroot ${SDK_PATH}" + +pushd ${NETTLE_NAME} + PKG_CONFIG_ALLOW_CROSS=1 PKG_CONFIG_PATH=$PREFIX/lib/pkgconfig CC_FOR_BUILD="$(whereis gcc)" ./configure --host=${HOST} --prefix=${CURRENT_LIB_DIR} --with-lib-path=${PREFIX}/lib --with-include-path=${PREFIX}/include --disable-assembler --disable-arm-neon --disable-documentation --verbose + make clean + make -j4 + make install +popd + +rm -rf *.gz From cbc970fbf98226055b65678e57893823373856ac Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 18:12:28 +0200 Subject: [PATCH 06/10] IOS-2882 Nettle 4 macOS and iconv 4 iOS works --- .../project.pbxproj | 162 ++++++++++++++++-- .../xcschemes/build_libiconv_iOS.xcscheme | 67 ++++++++ .../xcschemes/build_nettle_macOS.xcscheme | 67 ++++++++ 3 files changed, 286 insertions(+), 10 deletions(-) create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_libiconv_iOS.xcscheme create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_nettle_macOS.xcscheme diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index f66494e..fb8f193 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -52,6 +52,29 @@ name = build_nettle_iOS; productName = "libetpan-dependencies_macOS"; }; + 152E49A226A9CEE0009BD3CE /* build_nettle_macOS */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 152E49A426A9CEE0009BD3CE /* Build configuration list for PBXAggregateTarget "build_nettle_macOS" */; + buildPhases = ( + 152E49A326A9CEE0009BD3CE /* Build */, + ); + dependencies = ( + 152E49A826A9CF1E009BD3CE /* PBXTargetDependency */, + ); + name = build_nettle_macOS; + productName = "libetpan-dependencies_macOS"; + }; + 152E49AB26A9CFD4009BD3CE /* build_libiconv_iOS */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 152E49AD26A9CFD4009BD3CE /* Build configuration list for PBXAggregateTarget "build_libiconv_iOS" */; + buildPhases = ( + 152E49AC26A9CFD4009BD3CE /* Build */, + ); + dependencies = ( + ); + name = build_libiconv_iOS; + productName = "libetpan-dependencies_macOS"; + }; 1585EE16269DCEA600B822E1 /* build-pEpMIME-dependencies_macOS */ = { isa = PBXAggregateTarget; buildConfigurationList = 1585EE17269DCEA600B822E1 /* Build configuration list for PBXAggregateTarget "build-pEpMIME-dependencies_macOS" */; @@ -190,6 +213,7 @@ 1585EECB269EF0F100B822E1 /* Build */, ); dependencies = ( + 152E49AA26A9CF2D009BD3CE /* PBXTargetDependency */, ); name = build_sequoia_macOS; productName = "libetpan-dependencies_macOS"; @@ -223,7 +247,7 @@ 1585EF0626A0479800B822E1 /* Build */, ); dependencies = ( - 152E499326A9B88A009BD3CE /* PBXTargetDependency */, + 152E49A126A9CED3009BD3CE /* PBXTargetDependency */, ); name = build_sequoia_iOS; productName = "libetpan-dependencies_macOS"; @@ -267,19 +291,33 @@ /* End PBXAggregateTarget section */ /* Begin PBXContainerItemProxy section */ - 152E499226A9B88A009BD3CE /* PBXContainerItemProxy */ = { + 152E499E26A9C62B009BD3CE /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; proxyType = 1; remoteGlobalIDString = 152E498D26A9B252009BD3CE; remoteInfo = build_gmp_iOS; }; - 152E499E26A9C62B009BD3CE /* PBXContainerItemProxy */ = { + 152E49A026A9CED3009BD3CE /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; proxyType = 1; - remoteGlobalIDString = 152E498D26A9B252009BD3CE; - remoteInfo = build_gmp_iOS; + remoteGlobalIDString = 152E499926A9BC94009BD3CE; + remoteInfo = build_nettle_iOS; + }; + 152E49A726A9CF1E009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 152E499426A9B88E009BD3CE; + remoteInfo = build_gmp_macOS; + }; + 152E49A926A9CF2D009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 152E49A226A9CEE0009BD3CE; + remoteInfo = build_nettle_macOS; }; 1585EE35269EC8DD00B822E1 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; @@ -440,6 +478,7 @@ 1585EE48269ECB8700B822E1 /* build_cryptopp_macOS */, 1585EEA5269EDA1E00B822E1 /* build_asn1cexecutable */, 152E499426A9B88E009BD3CE /* build_gmp_macOS */, + 152E49A226A9CEE0009BD3CE /* build_nettle_macOS */, 1585EECA269EF0F100B822E1 /* build_sequoia_macOS */, 1585EE43269ECB2500B822E1 /* build_pEpwebserver_macOS */, 1585EEAA269EDAE200B822E1 /* build_pEpengine_macOS */, @@ -455,6 +494,7 @@ 152E498D26A9B252009BD3CE /* build_gmp_iOS */, 152E499926A9BC94009BD3CE /* build_nettle_iOS */, 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, + 152E49AB26A9CFD4009BD3CE /* build_libiconv_iOS */, 152E47C626A5B7C2009BD3CE /* CLEAN_ALL_iOS */, ); }; @@ -537,6 +577,44 @@ shellScript = "LIB_NAME=\"nettle\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; + 152E49A326A9CEE0009BD3CE /* Build */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = Build; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = "/bin/sh -l"; + shellScript = "LIB_NAME=\"nettle\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_mac_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; + showEnvVarsInLog = 0; + }; + 152E49AC26A9CFD4009BD3CE /* Build */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = Build; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "LIB_NAME=\"iconv\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; + showEnvVarsInLog = 0; + }; 1585EE28269DD87700B822E1 /* Build */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; @@ -806,16 +884,26 @@ /* End PBXShellScriptBuildPhase section */ /* Begin PBXTargetDependency section */ - 152E499326A9B88A009BD3CE /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = 152E498D26A9B252009BD3CE /* build_gmp_iOS */; - targetProxy = 152E499226A9B88A009BD3CE /* PBXContainerItemProxy */; - }; 152E499F26A9C62B009BD3CE /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 152E498D26A9B252009BD3CE /* build_gmp_iOS */; targetProxy = 152E499E26A9C62B009BD3CE /* PBXContainerItemProxy */; }; + 152E49A126A9CED3009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E499926A9BC94009BD3CE /* build_nettle_iOS */; + targetProxy = 152E49A026A9CED3009BD3CE /* PBXContainerItemProxy */; + }; + 152E49A826A9CF1E009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E499426A9B88E009BD3CE /* build_gmp_macOS */; + targetProxy = 152E49A726A9CF1E009BD3CE /* PBXContainerItemProxy */; + }; + 152E49AA26A9CF2D009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E49A226A9CEE0009BD3CE /* build_nettle_macOS */; + targetProxy = 152E49A926A9CF2D009BD3CE /* PBXContainerItemProxy */; + }; 1585EE36269EC8DD00B822E1 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 1585EE27269DD87700B822E1 /* build_libiconv_macOS */; @@ -976,6 +1064,42 @@ }; name = Release; }; + 152E49A526A9CEE0009BD3CE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 152E49A626A9CEE0009BD3CE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + 152E49AE26A9CFD4009BD3CE /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 152E49AF26A9CFD4009BD3CE /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + DEVELOPMENT_TEAM = NQLYU6MGPN; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; 1585EE0F269DC6DD00B822E1 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1351,6 +1475,24 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + 152E49A426A9CEE0009BD3CE /* Build configuration list for PBXAggregateTarget "build_nettle_macOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 152E49A526A9CEE0009BD3CE /* Debug */, + 152E49A626A9CEE0009BD3CE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 152E49AD26A9CFD4009BD3CE /* Build configuration list for PBXAggregateTarget "build_libiconv_iOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 152E49AE26A9CFD4009BD3CE /* Debug */, + 152E49AF26A9CFD4009BD3CE /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; 1585EE0E269DC6DD00B822E1 /* Build configuration list for PBXProject "CommonPEPDependencies" */ = { isa = XCConfigurationList; buildConfigurations = ( diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_libiconv_iOS.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_libiconv_iOS.xcscheme new file mode 100644 index 0000000..e93a2ad --- /dev/null +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_libiconv_iOS.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_nettle_macOS.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_nettle_macOS.xcscheme new file mode 100644 index 0000000..3002004 --- /dev/null +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/build_nettle_macOS.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + From 94850fb75a0f73cd3d827a14a929c671028da924 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Thu, 22 Jul 2021 18:52:38 +0200 Subject: [PATCH 07/10] IOS-2882 sequoia 4 iOS working --- .../project.pbxproj | 2 +- _config/pEp_versions.plist | 6 +- build-ios_dependency.template | 4 +- buildcode/sequoia.code | 50 ++++++++ .../sequoia_resources/nettle-bindings.rs | 108 ++++++++++++++++++ 5 files changed, 163 insertions(+), 7 deletions(-) create mode 100644 buildcode/sequoia.code create mode 100644 buildcode/sequoia_resources/nettle-bindings.rs diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index fb8f193..4bcf21e 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -859,7 +859,7 @@ ); runOnlyForDeploymentPostprocessing = 0; shellPath = "/bin/sh -l"; - shellScript = "# Note: `-l`(login shell) needed to find `wget`\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/build-sequoia-iOS.sh\" \nsh \"${BUILD_SCRIPT}\" \"${PREFIX}\"\n"; + shellScript = "LIB_NAME=\"sequoia\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_ios_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; 1585F04626A1C14C00B822E1 /* Build */ = { diff --git a/_config/pEp_versions.plist b/_config/pEp_versions.plist index 5000060..98c32cd 100644 --- a/_config/pEp_versions.plist +++ b/_config/pEp_versions.plist @@ -6,10 +6,8 @@ 3.7.3 GMP_VERSION 6.2.1 - SEQUOIA_4_iOS_VERSION - v2.1.6 - SEQUOIA_4_MAC_OS_VERSION - v2.1.6 + SEQUOIA_VERSION + openpgp/v1.3.0 PEP_ENGINE_VERSION Release_2.1.47 LIB_PEP_ADAPTER_VERSION diff --git a/build-ios_dependency.template b/build-ios_dependency.template index 32c91b9..fb4db30 100644 --- a/build-ios_dependency.template +++ b/build-ios_dependency.template @@ -1,4 +1,4 @@ -# Builds fat lib for macOS (ARM64 & x86_64). +# Builds fat lib for iOS (ARM64 & x86_64). # Pass PREFIX as argument. If not passed, "local/" is used as deafult. # Exit on errors @@ -60,7 +60,7 @@ buildLib() echo "Unhandled arch" exit 1 fi -fi + fi # START: Lib Specific Code diff --git a/buildcode/sequoia.code b/buildcode/sequoia.code new file mode 100644 index 0000000..089fb37 --- /dev/null +++ b/buildcode/sequoia.code @@ -0,0 +1,50 @@ +if [ -f "${PREFIX}/lib/libsequoia_openpgp_ffi.a" ]; then + echo "lib exists already in ${LIB_DIR}. If you want to rebuild it, delete the existing one." + exit 0 +fi + +VERSION=$(sh "${SCRIPT_DIR}/get-pEp-version.sh" "SEQUOIA_VERSION") + +SEQUOIA_DIR="${TMP_DIR}/sequoia" +if [ ! -d "${SEQUOIA_DIR}" ]; then + git clone -b ${VERSION} --depth 1 https://gitlab.com/sequoia-pgp/sequoia.git +fi + +NETTLE_BINDINGS="${SCRIPT_DIR}/buildcode/sequoia_resources/nettle-bindings.rs" +build_ios() +{ + cargo update + rustup run nightly cargo update + NETTLE_PREGENERATED_BINDINGS="${NETTLE_BINDINGS}" PKG_CONFIG_ALLOW_CROSS=1 RUST_BACKTRACE=1 PKG_CONFIG_PATH=$OUTPUT_DIR/${ARCH}/lib/pkgconfig RUSTFLAGS="-L ${CURRENT_LIB_DIR}/lib" rustup run nightly cargo build --target ${TARGET} -p sequoia-openpgp-ffi --release -Z build-std=core,alloc,std +} + +build_macos() +{ + if [ ${ARCH} == "arm64" ]; then + rustup run nightly cargo update + SDKROOT=$(xcrun -sdk ${SDK} --show-sdk-path) \ + # JSONAdapter needlessly requires libsequoia_ffi.a + NETTLE_PREGENERATED_BINDINGS="${SCRIPT_DIR}/nettle-bindings.rs" PKG_CONFIG_ALLOW_CROSS=1 RUST_BACKTRACE=full PKG_CONFIG_PATH=${CURRENT_LIB_DIR}/lib/pkgconfig RUSTFLAGS="-L ${PREFIX}/lib" rustup run nightly cargo build --target ${HOST} --release -Z build-std=core,alloc,std + elif [ ${ARCH} == "x86_64" ]; then + cargo update + SDKROOT=$(xcrun -sdk ${SDK} --show-sdk-path) \ + # JSONAdapter needlessly requires libsequoia_ffi.a + PKG_CONFIG_ALLOW_CROSS=1 RUST_BACKTRACE=full PKG_CONFIG_PATH=${CURRENT_LIB_DIR}/lib/pkgconfig RUSTFLAGS="-L ${PREFIX}/lib" cargo build --target ${HOST} --release + else + echo "Unhandled ARCH" + exit 1 + fi +} + + +pushd ${SEQUOIA_DIR} + if [[ $TARGET == *"ios"* ]]; then + build_ios + else + build_macos + fi +popd + +# copy artefacts +cp "${SEQUOIA_DIR}/target/${TARGET}/release"/*.a "${CURRENT_LIB_DIR}/lib" +cp -R "${SEQUOIA_DIR}/openpgp-ffi/include"/* "${CURRENT_LIB_DIR}/include/" \ No newline at end of file diff --git a/buildcode/sequoia_resources/nettle-bindings.rs b/buildcode/sequoia_resources/nettle-bindings.rs new file mode 100644 index 0000000..2694637 --- /dev/null +++ b/buildcode/sequoia_resources/nettle-bindings.rs @@ -0,0 +1,108 @@ +/* automatically generated by rust-bindgen */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + storage: Storage, + align: [Align; 0], +} + +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn new(storage: Storage) -> Self { + Self { + storage, + align: [], + } + } + + #[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]; + + 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 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]; + + 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 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 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); + } + } +} + pub const _STDINT_HAVE_INT_FAST32_T : u32 = 1 ; pub const __NETTLE_STDINT_H : u32 = 1 ; pub const _GENERATED_STDINT_H : & 'static [ u8 ; 2usize ] = b" \0" ; pub const _STDINT_HAVE_STDINT_H : u32 = 1 ; pub const __WORDSIZE : u32 = 64 ; pub const __DARWIN_ONLY_64_BIT_INO_T : u32 = 0 ; pub const __DARWIN_ONLY_VERS_1050 : u32 = 0 ; pub const __DARWIN_ONLY_UNIX_CONFORMANCE : u32 = 1 ; pub const __DARWIN_UNIX03 : u32 = 1 ; pub const __DARWIN_64_BIT_INO_T : u32 = 1 ; pub const __DARWIN_VERS_1050 : u32 = 1 ; pub const __DARWIN_NON_CANCELABLE : u32 = 0 ; pub const __DARWIN_SUF_64_BIT_INO_T : & 'static [ u8 ; 9usize ] = b"$INODE64\0" ; pub const __DARWIN_SUF_1050 : & 'static [ u8 ; 6usize ] = b"$1050\0" ; pub const __DARWIN_SUF_EXTSN : & 'static [ u8 ; 14usize ] = b"$DARWIN_EXTSN\0" ; pub const __DARWIN_C_ANSI : u32 = 4096 ; pub const __DARWIN_C_FULL : u32 = 900000 ; pub const __DARWIN_C_LEVEL : u32 = 900000 ; pub const __STDC_WANT_LIB_EXT1__ : u32 = 1 ; pub const __DARWIN_NO_LONG_LONG : u32 = 0 ; pub const _DARWIN_FEATURE_64_BIT_INODE : u32 = 1 ; pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE : u32 = 1 ; pub const _DARWIN_FEATURE_UNIX_CONFORMANCE : u32 = 3 ; pub const __PTHREAD_SIZE__ : u32 = 8176 ; pub const __PTHREAD_ATTR_SIZE__ : u32 = 56 ; pub const __PTHREAD_MUTEXATTR_SIZE__ : u32 = 8 ; pub const __PTHREAD_MUTEX_SIZE__ : u32 = 56 ; pub const __PTHREAD_CONDATTR_SIZE__ : u32 = 8 ; pub const __PTHREAD_COND_SIZE__ : u32 = 40 ; pub const __PTHREAD_ONCE_SIZE__ : u32 = 8 ; pub const __PTHREAD_RWLOCK_SIZE__ : u32 = 192 ; pub const __PTHREAD_RWLOCKATTR_SIZE__ : u32 = 16 ; 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 INT8_MIN : i32 = -128 ; pub const INT16_MIN : i32 = -32768 ; pub const INT32_MIN : i32 = -2147483648 ; pub const INT64_MIN : i64 = -9223372036854775808 ; 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_MAX : u64 = 9223372036854775807 ; pub const INTPTR_MIN : i64 = -9223372036854775808 ; 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 SIZE_MAX : i32 = -1 ; pub const RSIZE_MAX : i32 = -1 ; pub const WINT_MIN : i32 = -2147483648 ; pub const WINT_MAX : u32 = 2147483647 ; pub const SIG_ATOMIC_MIN : i32 = -2147483648 ; pub const SIG_ATOMIC_MAX : u32 = 2147483647 ; pub const AES_BLOCK_SIZE : u32 = 16 ; pub const AES128_KEY_SIZE : u32 = 16 ; pub const AES192_KEY_SIZE : u32 = 24 ; pub const AES256_KEY_SIZE : u32 = 32 ; pub const _AES128_ROUNDS : u32 = 10 ; pub const _AES192_ROUNDS : u32 = 12 ; pub const _AES256_ROUNDS : u32 = 14 ; pub const AES_MIN_KEY_SIZE : u32 = 16 ; pub const AES_MAX_KEY_SIZE : u32 = 32 ; pub const AES_KEY_SIZE : u32 = 32 ; pub const ARCFOUR_MIN_KEY_SIZE : u32 = 1 ; pub const ARCFOUR_MAX_KEY_SIZE : u32 = 256 ; pub const ARCFOUR_KEY_SIZE : u32 = 16 ; pub const ARCFOUR128_KEY_SIZE : u32 = 16 ; pub const ARCTWO_BLOCK_SIZE : u32 = 8 ; pub const ARCTWO_MIN_KEY_SIZE : u32 = 1 ; pub const ARCTWO_MAX_KEY_SIZE : u32 = 128 ; pub const ARCTWO_KEY_SIZE : u32 = 8 ; pub const BASE64_BINARY_BLOCK_SIZE : u32 = 3 ; pub const BASE64_TEXT_BLOCK_SIZE : u32 = 4 ; pub const BASE64_ENCODE_FINAL_LENGTH : u32 = 3 ; pub const NETTLE_VERSION_MAJOR : u32 = 3 ; pub const NETTLE_VERSION_MINOR : u32 = 4 ; pub const NETTLE_USE_MINI_GMP : u32 = 0 ; pub const __GMP_HAVE_HOST_CPU_FAMILY_power : u32 = 0 ; pub const __GMP_HAVE_HOST_CPU_FAMILY_powerpc : u32 = 0 ; pub const GMP_LIMB_BITS : u32 = 64 ; pub const GMP_NAIL_BITS : u32 = 0 ; pub const GMP_NUMB_BITS : u32 = 64 ; pub const __GNU_MP__ : u32 = 6 ; pub const __DARWIN_CLK_TCK : u32 = 100 ; pub const CHAR_BIT : u32 = 8 ; pub const MB_LEN_MAX : u32 = 6 ; pub const CLK_TCK : u32 = 100 ; pub const SCHAR_MAX : u32 = 127 ; pub const SCHAR_MIN : i32 = -128 ; pub const UCHAR_MAX : u32 = 255 ; pub const CHAR_MAX : u32 = 127 ; pub const CHAR_MIN : i32 = -128 ; pub const USHRT_MAX : u32 = 65535 ; pub const SHRT_MAX : u32 = 32767 ; pub const SHRT_MIN : i32 = -32768 ; pub const UINT_MAX : u32 = 4294967295 ; pub const INT_MAX : u32 = 2147483647 ; pub const INT_MIN : i32 = -2147483648 ; pub const ULONG_MAX : i32 = -1 ; pub const LONG_MAX : u64 = 9223372036854775807 ; pub const LONG_MIN : i64 = -9223372036854775808 ; pub const ULLONG_MAX : i32 = -1 ; pub const LLONG_MAX : u64 = 9223372036854775807 ; pub const LLONG_MIN : i64 = -9223372036854775808 ; pub const LONG_BIT : u32 = 64 ; pub const SSIZE_MAX : u64 = 9223372036854775807 ; pub const WORD_BIT : u32 = 32 ; pub const SIZE_T_MAX : i32 = -1 ; pub const UQUAD_MAX : i32 = -1 ; pub const QUAD_MAX : u64 = 9223372036854775807 ; pub const QUAD_MIN : i64 = -9223372036854775808 ; pub const ARG_MAX : u32 = 262144 ; pub const CHILD_MAX : u32 = 266 ; pub const GID_MAX : u32 = 2147483647 ; pub const LINK_MAX : u32 = 32767 ; pub const MAX_CANON : u32 = 1024 ; pub const MAX_INPUT : u32 = 1024 ; pub const NAME_MAX : u32 = 255 ; pub const NGROUPS_MAX : u32 = 16 ; pub const UID_MAX : u32 = 2147483647 ; pub const OPEN_MAX : u32 = 10240 ; pub const PATH_MAX : u32 = 1024 ; pub const PIPE_BUF : u32 = 512 ; pub const BC_BASE_MAX : u32 = 99 ; pub const BC_DIM_MAX : u32 = 2048 ; pub const BC_SCALE_MAX : u32 = 99 ; pub const BC_STRING_MAX : u32 = 1000 ; pub const CHARCLASS_NAME_MAX : u32 = 14 ; pub const COLL_WEIGHTS_MAX : u32 = 2 ; pub const EQUIV_CLASS_MAX : u32 = 2 ; pub const EXPR_NEST_MAX : u32 = 32 ; pub const LINE_MAX : u32 = 2048 ; pub const RE_DUP_MAX : u32 = 255 ; pub const NZERO : u32 = 20 ; pub const _POSIX_ARG_MAX : u32 = 4096 ; pub const _POSIX_CHILD_MAX : u32 = 25 ; pub const _POSIX_LINK_MAX : u32 = 8 ; pub const _POSIX_MAX_CANON : u32 = 255 ; pub const _POSIX_MAX_INPUT : u32 = 255 ; pub const _POSIX_NAME_MAX : u32 = 14 ; pub const _POSIX_NGROUPS_MAX : u32 = 8 ; pub const _POSIX_OPEN_MAX : u32 = 20 ; pub const _POSIX_PATH_MAX : u32 = 256 ; pub const _POSIX_PIPE_BUF : u32 = 512 ; pub const _POSIX_SSIZE_MAX : u32 = 32767 ; pub const _POSIX_STREAM_MAX : u32 = 8 ; pub const _POSIX_TZNAME_MAX : u32 = 6 ; pub const _POSIX2_BC_BASE_MAX : u32 = 99 ; pub const _POSIX2_BC_DIM_MAX : u32 = 2048 ; pub const _POSIX2_BC_SCALE_MAX : u32 = 99 ; pub const _POSIX2_BC_STRING_MAX : u32 = 1000 ; pub const _POSIX2_EQUIV_CLASS_MAX : u32 = 2 ; pub const _POSIX2_EXPR_NEST_MAX : u32 = 32 ; pub const _POSIX2_LINE_MAX : u32 = 2048 ; pub const _POSIX2_RE_DUP_MAX : u32 = 255 ; pub const _POSIX_AIO_LISTIO_MAX : u32 = 2 ; pub const _POSIX_AIO_MAX : u32 = 1 ; pub const _POSIX_DELAYTIMER_MAX : u32 = 32 ; pub const _POSIX_MQ_OPEN_MAX : u32 = 8 ; pub const _POSIX_MQ_PRIO_MAX : u32 = 32 ; pub const _POSIX_RTSIG_MAX : u32 = 8 ; pub const _POSIX_SEM_NSEMS_MAX : u32 = 256 ; pub const _POSIX_SEM_VALUE_MAX : u32 = 32767 ; pub const _POSIX_SIGQUEUE_MAX : u32 = 32 ; pub const _POSIX_TIMER_MAX : u32 = 32 ; pub const _POSIX_CLOCKRES_MIN : u32 = 20000000 ; pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS : u32 = 4 ; pub const _POSIX_THREAD_KEYS_MAX : u32 = 128 ; pub const _POSIX_THREAD_THREADS_MAX : u32 = 64 ; pub const PTHREAD_DESTRUCTOR_ITERATIONS : u32 = 4 ; pub const PTHREAD_KEYS_MAX : u32 = 512 ; pub const PTHREAD_STACK_MIN : u32 = 8192 ; pub const _POSIX_HOST_NAME_MAX : u32 = 255 ; pub const _POSIX_LOGIN_NAME_MAX : u32 = 9 ; pub const _POSIX_SS_REPL_MAX : u32 = 4 ; pub const _POSIX_SYMLINK_MAX : u32 = 255 ; pub const _POSIX_SYMLOOP_MAX : u32 = 8 ; pub const _POSIX_TRACE_EVENT_NAME_MAX : u32 = 30 ; pub const _POSIX_TRACE_NAME_MAX : u32 = 8 ; pub const _POSIX_TRACE_SYS_MAX : u32 = 8 ; pub const _POSIX_TRACE_USER_EVENT_MAX : u32 = 32 ; pub const _POSIX_TTY_NAME_MAX : u32 = 9 ; pub const _POSIX2_CHARCLASS_NAME_MAX : u32 = 14 ; pub const _POSIX2_COLL_WEIGHTS_MAX : u32 = 2 ; pub const _POSIX_RE_DUP_MAX : u32 = 255 ; pub const OFF_MIN : i64 = -9223372036854775808 ; pub const OFF_MAX : u64 = 9223372036854775807 ; pub const PASS_MAX : u32 = 128 ; pub const NL_ARGMAX : u32 = 9 ; pub const NL_LANGMAX : u32 = 14 ; pub const NL_MSGMAX : u32 = 32767 ; pub const NL_NMAX : u32 = 1 ; pub const NL_SETMAX : u32 = 255 ; pub const NL_TEXTMAX : u32 = 2048 ; pub const _XOPEN_IOV_MAX : u32 = 16 ; pub const IOV_MAX : u32 = 1024 ; pub const _XOPEN_NAME_MAX : u32 = 255 ; pub const _XOPEN_PATH_MAX : u32 = 1024 ; pub const __GMP_LIBGMP_DLL : u32 = 0 ; pub const __GMP_MP_SIZE_T_INT : u32 = 0 ; pub const __GMP_INLINE_PROTOTYPES : u32 = 1 ; pub const __GMP_CC : & 'static [ u8 ; 15usize ] = b"/usr/bin/clang\0" ; pub const __GMP_CFLAGS : & 'static [ u8 ; 74usize ] = b"-O2 -pedantic -fomit-frame-pointer -m64 -mtune=broadwell -march=broadwell\0" ; pub const __GNU_MP_VERSION : u32 = 6 ; pub const __GNU_MP_VERSION_MINOR : u32 = 1 ; pub const __GNU_MP_VERSION_PATCHLEVEL : u32 = 2 ; pub const __GNU_MP_RELEASE : u32 = 60102 ; pub const BLOWFISH_BLOCK_SIZE : u32 = 8 ; pub const BLOWFISH_MIN_KEY_SIZE : u32 = 8 ; pub const BLOWFISH_MAX_KEY_SIZE : u32 = 56 ; pub const BLOWFISH_KEY_SIZE : u32 = 16 ; pub const BLOWFISH128_KEY_SIZE : u32 = 16 ; pub const _BLOWFISH_ROUNDS : u32 = 16 ; pub const CAMELLIA_BLOCK_SIZE : u32 = 16 ; pub const CAMELLIA128_KEY_SIZE : u32 = 16 ; pub const CAMELLIA192_KEY_SIZE : u32 = 24 ; pub const CAMELLIA256_KEY_SIZE : u32 = 32 ; pub const _CAMELLIA128_NKEYS : u32 = 24 ; pub const _CAMELLIA256_NKEYS : u32 = 32 ; pub const CAST128_BLOCK_SIZE : u32 = 8 ; pub const CAST5_MIN_KEY_SIZE : u32 = 5 ; pub const CAST5_MAX_KEY_SIZE : u32 = 16 ; pub const CAST128_KEY_SIZE : u32 = 16 ; pub const CCM_BLOCK_SIZE : u32 = 16 ; pub const CCM_DIGEST_SIZE : u32 = 16 ; pub const CCM_MIN_NONCE_SIZE : u32 = 7 ; pub const CCM_MAX_NONCE_SIZE : u32 = 14 ; pub const CHACHA_KEY_SIZE : u32 = 32 ; pub const CHACHA_BLOCK_SIZE : u32 = 64 ; pub const CHACHA_NONCE_SIZE : u32 = 8 ; pub const CHACHA_NONCE96_SIZE : u32 = 12 ; pub const _CHACHA_STATE_LENGTH : u32 = 16 ; pub const POLY1305_DIGEST_SIZE : u32 = 16 ; pub const POLY1305_BLOCK_SIZE : u32 = 16 ; pub const POLY1305_KEY_SIZE : u32 = 16 ; pub const POLY1305_AES_KEY_SIZE : u32 = 32 ; pub const POLY1305_AES_DIGEST_SIZE : u32 = 16 ; pub const POLY1305_AES_NONCE_SIZE : u32 = 16 ; pub const CHACHA_POLY1305_BLOCK_SIZE : u32 = 64 ; pub const CHACHA_POLY1305_KEY_SIZE : u32 = 32 ; pub const CHACHA_POLY1305_NONCE_SIZE : u32 = 12 ; pub const CHACHA_POLY1305_DIGEST_SIZE : u32 = 16 ; pub const CURVE25519_SIZE : u32 = 32 ; pub const NETTLE_CURVE25519_RFC7748 : u32 = 1 ; pub const DES_KEY_SIZE : u32 = 8 ; pub const DES_BLOCK_SIZE : u32 = 8 ; pub const _DES_KEY_LENGTH : u32 = 32 ; pub const DES3_KEY_SIZE : u32 = 24 ; pub const DES3_BLOCK_SIZE : u32 = 8 ; pub const DSA_SHA1_MIN_P_BITS : u32 = 512 ; pub const DSA_SHA1_Q_OCTETS : u32 = 20 ; pub const DSA_SHA1_Q_BITS : u32 = 160 ; pub const DSA_SHA256_MIN_P_BITS : u32 = 1024 ; pub const DSA_SHA256_Q_OCTETS : u32 = 32 ; pub const DSA_SHA256_Q_BITS : u32 = 256 ; pub const SHA1_DIGEST_SIZE : u32 = 20 ; pub const SHA1_BLOCK_SIZE : u32 = 64 ; pub const SHA1_DATA_SIZE : u32 = 64 ; pub const _SHA1_DIGEST_LENGTH : u32 = 5 ; pub const SHA256_DIGEST_SIZE : u32 = 32 ; pub const SHA256_BLOCK_SIZE : u32 = 64 ; pub const _SHA256_DIGEST_LENGTH : u32 = 8 ; pub const SHA224_DIGEST_SIZE : u32 = 28 ; pub const SHA224_BLOCK_SIZE : u32 = 64 ; pub const SHA512_DIGEST_SIZE : u32 = 64 ; pub const SHA512_BLOCK_SIZE : u32 = 128 ; pub const _SHA512_DIGEST_LENGTH : u32 = 8 ; pub const SHA384_DIGEST_SIZE : u32 = 48 ; pub const SHA384_BLOCK_SIZE : u32 = 128 ; pub const SHA512_224_DIGEST_SIZE : u32 = 28 ; pub const SHA512_224_BLOCK_SIZE : u32 = 128 ; pub const SHA512_256_DIGEST_SIZE : u32 = 32 ; pub const SHA512_256_BLOCK_SIZE : u32 = 128 ; pub const EAX_BLOCK_SIZE : u32 = 16 ; pub const EAX_DIGEST_SIZE : u32 = 16 ; pub const EAX_IV_SIZE : u32 = 16 ; pub const ED25519_KEY_SIZE : u32 = 32 ; pub const ED25519_SIGNATURE_SIZE : u32 = 64 ; pub const GCM_BLOCK_SIZE : u32 = 16 ; pub const GCM_IV_SIZE : u32 = 12 ; pub const GCM_DIGEST_SIZE : u32 = 16 ; pub const GCM_TABLE_BITS : u32 = 8 ; pub const GOSTHASH94_BLOCK_SIZE : u32 = 32 ; pub const GOSTHASH94_DIGEST_SIZE : u32 = 32 ; pub const GOSTHASH94_DATA_SIZE : u32 = 32 ; pub const MD5_DIGEST_SIZE : u32 = 16 ; pub const MD5_BLOCK_SIZE : u32 = 64 ; pub const MD5_DATA_SIZE : u32 = 64 ; pub const _MD5_DIGEST_LENGTH : u32 = 4 ; pub const RIPEMD160_DIGEST_SIZE : u32 = 20 ; pub const RIPEMD160_BLOCK_SIZE : u32 = 64 ; pub const RIPEMD160_DATA_SIZE : u32 = 64 ; pub const _RIPEMD160_DIGEST_LENGTH : u32 = 5 ; pub const _KNUTH_LFIB_KK : u32 = 100 ; pub const MD2_DIGEST_SIZE : u32 = 16 ; pub const MD2_BLOCK_SIZE : u32 = 16 ; pub const MD2_DATA_SIZE : u32 = 16 ; pub const MD4_DIGEST_SIZE : u32 = 16 ; pub const MD4_BLOCK_SIZE : u32 = 64 ; pub const MD4_DATA_SIZE : u32 = 64 ; pub const _MD4_DIGEST_LENGTH : u32 = 4 ; pub const __API_TO_BE_DEPRECATED : u32 = 100000 ; pub const __MAC_10_0 : u32 = 1000 ; pub const __MAC_10_1 : u32 = 1010 ; pub const __MAC_10_2 : u32 = 1020 ; pub const __MAC_10_3 : u32 = 1030 ; pub const __MAC_10_4 : u32 = 1040 ; pub const __MAC_10_5 : u32 = 1050 ; pub const __MAC_10_6 : u32 = 1060 ; pub const __MAC_10_7 : u32 = 1070 ; pub const __MAC_10_8 : u32 = 1080 ; pub const __MAC_10_9 : u32 = 1090 ; pub const __MAC_10_10 : u32 = 101000 ; pub const __MAC_10_10_2 : u32 = 101002 ; pub const __MAC_10_10_3 : u32 = 101003 ; pub const __MAC_10_11 : u32 = 101100 ; pub const __MAC_10_11_2 : u32 = 101102 ; pub const __MAC_10_11_3 : u32 = 101103 ; pub const __MAC_10_11_4 : u32 = 101104 ; pub const __MAC_10_12 : u32 = 101200 ; pub const __MAC_10_12_1 : u32 = 101201 ; pub const __MAC_10_12_2 : u32 = 101202 ; pub const __MAC_10_12_4 : u32 = 101204 ; pub const __MAC_10_13 : u32 = 101300 ; pub const __MAC_10_13_1 : u32 = 101301 ; pub const __MAC_10_13_2 : u32 = 101302 ; pub const __MAC_10_13_4 : u32 = 101304 ; pub const __MAC_10_14 : u32 = 101400 ; pub const __MAC_10_14_1 : u32 = 101401 ; pub const __MAC_10_14_4 : u32 = 101404 ; pub const __IPHONE_2_0 : u32 = 20000 ; pub const __IPHONE_2_1 : u32 = 20100 ; pub const __IPHONE_2_2 : u32 = 20200 ; pub const __IPHONE_3_0 : u32 = 30000 ; pub const __IPHONE_3_1 : u32 = 30100 ; pub const __IPHONE_3_2 : u32 = 30200 ; pub const __IPHONE_4_0 : u32 = 40000 ; pub const __IPHONE_4_1 : u32 = 40100 ; pub const __IPHONE_4_2 : u32 = 40200 ; pub const __IPHONE_4_3 : u32 = 40300 ; pub const __IPHONE_5_0 : u32 = 50000 ; pub const __IPHONE_5_1 : u32 = 50100 ; pub const __IPHONE_6_0 : u32 = 60000 ; pub const __IPHONE_6_1 : u32 = 60100 ; pub const __IPHONE_7_0 : u32 = 70000 ; pub const __IPHONE_7_1 : u32 = 70100 ; pub const __IPHONE_8_0 : u32 = 80000 ; pub const __IPHONE_8_1 : u32 = 80100 ; pub const __IPHONE_8_2 : u32 = 80200 ; pub const __IPHONE_8_3 : u32 = 80300 ; pub const __IPHONE_8_4 : u32 = 80400 ; pub const __IPHONE_9_0 : u32 = 90000 ; pub const __IPHONE_9_1 : u32 = 90100 ; pub const __IPHONE_9_2 : u32 = 90200 ; pub const __IPHONE_9_3 : u32 = 90300 ; pub const __IPHONE_10_0 : u32 = 100000 ; pub const __IPHONE_10_1 : u32 = 100100 ; pub const __IPHONE_10_2 : u32 = 100200 ; pub const __IPHONE_10_3 : u32 = 100300 ; pub const __IPHONE_11_0 : u32 = 110000 ; pub const __IPHONE_11_1 : u32 = 110100 ; pub const __IPHONE_11_2 : u32 = 110200 ; pub const __IPHONE_11_3 : u32 = 110300 ; pub const __IPHONE_11_4 : u32 = 110400 ; pub const __IPHONE_12_0 : u32 = 120000 ; pub const __IPHONE_12_1 : u32 = 120100 ; pub const __IPHONE_12_2 : u32 = 120200 ; pub const __TVOS_9_0 : u32 = 90000 ; pub const __TVOS_9_1 : u32 = 90100 ; pub const __TVOS_9_2 : u32 = 90200 ; pub const __TVOS_10_0 : u32 = 100000 ; pub const __TVOS_10_0_1 : u32 = 100001 ; pub const __TVOS_10_1 : u32 = 100100 ; pub const __TVOS_10_2 : u32 = 100200 ; pub const __TVOS_11_0 : u32 = 110000 ; pub const __TVOS_11_1 : u32 = 110100 ; pub const __TVOS_11_2 : u32 = 110200 ; pub const __TVOS_11_3 : u32 = 110300 ; pub const __TVOS_11_4 : u32 = 110400 ; pub const __TVOS_12_0 : u32 = 120000 ; pub const __TVOS_12_1 : u32 = 120100 ; pub const __TVOS_12_2 : u32 = 120200 ; pub const __WATCHOS_1_0 : u32 = 10000 ; pub const __WATCHOS_2_0 : u32 = 20000 ; pub const __WATCHOS_2_1 : u32 = 20100 ; pub const __WATCHOS_2_2 : u32 = 20200 ; pub const __WATCHOS_3_0 : u32 = 30000 ; pub const __WATCHOS_3_1 : u32 = 30100 ; pub const __WATCHOS_3_1_1 : u32 = 30101 ; pub const __WATCHOS_3_2 : u32 = 30200 ; pub const __WATCHOS_4_0 : u32 = 40000 ; pub const __WATCHOS_4_1 : u32 = 40100 ; pub const __WATCHOS_4_2 : u32 = 40200 ; pub const __WATCHOS_4_3 : u32 = 40300 ; pub const __WATCHOS_5_0 : u32 = 50000 ; pub const __WATCHOS_5_1 : u32 = 50100 ; pub const __WATCHOS_5_2 : u32 = 50200 ; pub const __MAC_OS_X_VERSION_MAX_ALLOWED : u32 = 101404 ; pub const __DARWIN_WCHAR_MIN : i32 = -2147483648 ; pub const _FORTIFY_SOURCE : u32 = 2 ; pub const __DARWIN_NSIG : u32 = 32 ; pub const NSIG : u32 = 32 ; pub const _I386_SIGNAL_H_ : u32 = 1 ; pub const SIGHUP : u32 = 1 ; pub const SIGINT : u32 = 2 ; pub const SIGQUIT : u32 = 3 ; pub const SIGILL : u32 = 4 ; pub const SIGTRAP : u32 = 5 ; pub const SIGABRT : u32 = 6 ; pub const SIGIOT : u32 = 6 ; pub const SIGEMT : u32 = 7 ; pub const SIGFPE : u32 = 8 ; pub const SIGKILL : u32 = 9 ; pub const SIGBUS : u32 = 10 ; pub const SIGSEGV : u32 = 11 ; pub const SIGSYS : u32 = 12 ; pub const SIGPIPE : u32 = 13 ; pub const SIGALRM : u32 = 14 ; pub const SIGTERM : u32 = 15 ; pub const SIGURG : u32 = 16 ; pub const SIGSTOP : u32 = 17 ; pub const SIGTSTP : u32 = 18 ; pub const SIGCONT : u32 = 19 ; pub const SIGCHLD : u32 = 20 ; pub const SIGTTIN : u32 = 21 ; pub const SIGTTOU : u32 = 22 ; pub const SIGIO : u32 = 23 ; pub const SIGXCPU : u32 = 24 ; pub const SIGXFSZ : u32 = 25 ; pub const SIGVTALRM : u32 = 26 ; pub const SIGPROF : u32 = 27 ; pub const SIGWINCH : u32 = 28 ; pub const SIGINFO : u32 = 29 ; pub const SIGUSR1 : u32 = 30 ; pub const SIGUSR2 : u32 = 31 ; pub const FP_PREC_24B : u32 = 0 ; pub const FP_PREC_53B : u32 = 2 ; pub const FP_PREC_64B : u32 = 3 ; pub const FP_RND_NEAR : u32 = 0 ; pub const FP_RND_DOWN : u32 = 1 ; pub const FP_RND_UP : u32 = 2 ; pub const FP_CHOP : u32 = 3 ; pub const FP_STATE_BYTES : u32 = 512 ; pub const SIGEV_NONE : u32 = 0 ; pub const SIGEV_SIGNAL : u32 = 1 ; pub const SIGEV_THREAD : u32 = 3 ; pub const ILL_NOOP : u32 = 0 ; pub const ILL_ILLOPC : u32 = 1 ; pub const ILL_ILLTRP : u32 = 2 ; pub const ILL_PRVOPC : u32 = 3 ; pub const ILL_ILLOPN : u32 = 4 ; pub const ILL_ILLADR : u32 = 5 ; pub const ILL_PRVREG : u32 = 6 ; pub const ILL_COPROC : u32 = 7 ; pub const ILL_BADSTK : u32 = 8 ; pub const FPE_NOOP : u32 = 0 ; pub const FPE_FLTDIV : u32 = 1 ; pub const FPE_FLTOVF : u32 = 2 ; pub const FPE_FLTUND : u32 = 3 ; pub const FPE_FLTRES : u32 = 4 ; pub const FPE_FLTINV : u32 = 5 ; pub const FPE_FLTSUB : u32 = 6 ; pub const FPE_INTDIV : u32 = 7 ; pub const FPE_INTOVF : u32 = 8 ; pub const SEGV_NOOP : u32 = 0 ; pub const SEGV_MAPERR : u32 = 1 ; pub const SEGV_ACCERR : u32 = 2 ; pub const BUS_NOOP : u32 = 0 ; pub const BUS_ADRALN : u32 = 1 ; pub const BUS_ADRERR : u32 = 2 ; pub const BUS_OBJERR : u32 = 3 ; pub const TRAP_BRKPT : u32 = 1 ; pub const TRAP_TRACE : u32 = 2 ; pub const CLD_NOOP : u32 = 0 ; pub const CLD_EXITED : u32 = 1 ; pub const CLD_KILLED : u32 = 2 ; pub const CLD_DUMPED : u32 = 3 ; pub const CLD_TRAPPED : u32 = 4 ; pub const CLD_STOPPED : u32 = 5 ; pub const CLD_CONTINUED : u32 = 6 ; pub const POLL_IN : u32 = 1 ; pub const POLL_OUT : u32 = 2 ; pub const POLL_MSG : u32 = 3 ; pub const POLL_ERR : u32 = 4 ; pub const POLL_PRI : u32 = 5 ; pub const POLL_HUP : u32 = 6 ; pub const SA_ONSTACK : u32 = 1 ; pub const SA_RESTART : u32 = 2 ; pub const SA_RESETHAND : u32 = 4 ; pub const SA_NOCLDSTOP : u32 = 8 ; pub const SA_NODEFER : u32 = 16 ; pub const SA_NOCLDWAIT : u32 = 32 ; pub const SA_SIGINFO : u32 = 64 ; pub const SA_USERTRAMP : u32 = 256 ; pub const SA_64REGSET : u32 = 512 ; pub const SA_USERSPACE_MASK : u32 = 127 ; pub const SIG_BLOCK : u32 = 1 ; pub const SIG_UNBLOCK : u32 = 2 ; pub const SIG_SETMASK : u32 = 3 ; pub const SI_USER : u32 = 65537 ; pub const SI_QUEUE : u32 = 65538 ; pub const SI_TIMER : u32 = 65539 ; pub const SI_ASYNCIO : u32 = 65540 ; pub const SI_MESGQ : u32 = 65541 ; pub const SS_ONSTACK : u32 = 1 ; pub const SS_DISABLE : u32 = 4 ; pub const MINSIGSTKSZ : u32 = 32768 ; pub const SIGSTKSZ : u32 = 131072 ; pub const SV_ONSTACK : u32 = 1 ; pub const SV_INTERRUPT : u32 = 2 ; pub const SV_RESETHAND : u32 = 4 ; pub const SV_NODEFER : u32 = 16 ; pub const SV_NOCLDSTOP : u32 = 8 ; pub const SV_SIGINFO : u32 = 64 ; pub const PRIO_PROCESS : u32 = 0 ; pub const PRIO_PGRP : u32 = 1 ; pub const PRIO_USER : u32 = 2 ; pub const PRIO_DARWIN_THREAD : u32 = 3 ; pub const PRIO_DARWIN_PROCESS : u32 = 4 ; pub const PRIO_MIN : i32 = -20 ; pub const PRIO_MAX : u32 = 20 ; pub const PRIO_DARWIN_BG : u32 = 4096 ; pub const PRIO_DARWIN_NONUI : u32 = 4097 ; pub const RUSAGE_SELF : u32 = 0 ; pub const RUSAGE_CHILDREN : i32 = -1 ; pub const RUSAGE_INFO_V0 : u32 = 0 ; pub const RUSAGE_INFO_V1 : u32 = 1 ; pub const RUSAGE_INFO_V2 : u32 = 2 ; pub const RUSAGE_INFO_V3 : u32 = 3 ; pub const RUSAGE_INFO_V4 : u32 = 4 ; pub const RUSAGE_INFO_CURRENT : u32 = 4 ; pub const RLIMIT_CPU : u32 = 0 ; pub const RLIMIT_FSIZE : u32 = 1 ; pub const RLIMIT_DATA : u32 = 2 ; pub const RLIMIT_STACK : u32 = 3 ; pub const RLIMIT_CORE : u32 = 4 ; pub const RLIMIT_AS : u32 = 5 ; pub const RLIMIT_RSS : u32 = 5 ; pub const RLIMIT_MEMLOCK : u32 = 6 ; pub const RLIMIT_NPROC : u32 = 7 ; pub const RLIMIT_NOFILE : u32 = 8 ; pub const RLIM_NLIMITS : u32 = 9 ; pub const _RLIMIT_POSIX_FLAG : u32 = 4096 ; pub const RLIMIT_WAKEUPS_MONITOR : u32 = 1 ; pub const RLIMIT_CPU_USAGE_MONITOR : u32 = 2 ; pub const RLIMIT_THREAD_CPULIMITS : u32 = 3 ; pub const RLIMIT_FOOTPRINT_INTERVAL : u32 = 4 ; pub const WAKEMON_ENABLE : u32 = 1 ; pub const WAKEMON_DISABLE : u32 = 2 ; pub const WAKEMON_GET_PARAMS : u32 = 4 ; pub const WAKEMON_SET_DEFAULTS : u32 = 8 ; pub const WAKEMON_MAKE_FATAL : u32 = 16 ; pub const CPUMON_MAKE_FATAL : u32 = 4096 ; pub const FOOTPRINT_INTERVAL_RESET : u32 = 1 ; pub const IOPOL_TYPE_DISK : u32 = 0 ; pub const IOPOL_TYPE_VFS_ATIME_UPDATES : u32 = 2 ; pub const IOPOL_SCOPE_PROCESS : u32 = 0 ; pub const IOPOL_SCOPE_THREAD : u32 = 1 ; pub const IOPOL_SCOPE_DARWIN_BG : u32 = 2 ; pub const IOPOL_DEFAULT : u32 = 0 ; pub const IOPOL_IMPORTANT : u32 = 1 ; pub const IOPOL_PASSIVE : u32 = 2 ; pub const IOPOL_THROTTLE : u32 = 3 ; pub const IOPOL_UTILITY : u32 = 4 ; pub const IOPOL_STANDARD : u32 = 5 ; pub const IOPOL_APPLICATION : u32 = 5 ; pub const IOPOL_NORMAL : u32 = 1 ; pub const IOPOL_ATIME_UPDATES_DEFAULT : u32 = 0 ; pub const IOPOL_ATIME_UPDATES_OFF : u32 = 1 ; pub const WNOHANG : u32 = 1 ; pub const WUNTRACED : u32 = 2 ; pub const WCOREFLAG : u32 = 128 ; pub const _WSTOPPED : u32 = 127 ; pub const WEXITED : u32 = 4 ; pub const WSTOPPED : u32 = 8 ; pub const WCONTINUED : u32 = 16 ; pub const WNOWAIT : u32 = 32 ; pub const WAIT_ANY : i32 = -1 ; pub const WAIT_MYPGRP : u32 = 0 ; pub const _QUAD_HIGHWORD : u32 = 1 ; pub const _QUAD_LOWWORD : u32 = 0 ; pub const __DARWIN_LITTLE_ENDIAN : u32 = 1234 ; pub const __DARWIN_BIG_ENDIAN : u32 = 4321 ; pub const __DARWIN_PDP_ENDIAN : u32 = 3412 ; pub const __DARWIN_BYTE_ORDER : u32 = 1234 ; pub const LITTLE_ENDIAN : u32 = 1234 ; pub const BIG_ENDIAN : u32 = 4321 ; pub const PDP_ENDIAN : u32 = 3412 ; pub const BYTE_ORDER : u32 = 1234 ; pub const EXIT_FAILURE : u32 = 1 ; pub const EXIT_SUCCESS : u32 = 0 ; pub const RAND_MAX : u32 = 2147483647 ; pub const CLOCKS_PER_SEC : u32 = 1000000 ; pub const RSA_MINIMUM_N_OCTETS : u32 = 12 ; pub const RSA_MINIMUM_N_BITS : u32 = 89 ; pub const SALSA20_128_KEY_SIZE : u32 = 16 ; pub const SALSA20_256_KEY_SIZE : u32 = 32 ; pub const SALSA20_BLOCK_SIZE : u32 = 64 ; pub const SALSA20_NONCE_SIZE : u32 = 8 ; pub const SALSA20_IV_SIZE : u32 = 8 ; pub const SALSA20_MIN_KEY_SIZE : u32 = 16 ; pub const SALSA20_MAX_KEY_SIZE : u32 = 32 ; pub const SALSA20_KEY_SIZE : u32 = 32 ; pub const _SALSA20_INPUT_LENGTH : u32 = 16 ; pub const SERPENT_BLOCK_SIZE : u32 = 16 ; pub const SERPENT_KEY_SIZE : u32 = 32 ; pub const SERPENT_MIN_KEY_SIZE : u32 = 16 ; pub const SERPENT_MAX_KEY_SIZE : u32 = 32 ; pub const SERPENT128_KEY_SIZE : u32 = 16 ; pub const SERPENT192_KEY_SIZE : u32 = 24 ; pub const SERPENT256_KEY_SIZE : u32 = 32 ; pub const __GNUC_VA_LIST : u32 = 1 ; pub const NETTLE_SHA3_FIPS202 : u32 = 1 ; pub const SHA3_STATE_LENGTH : u32 = 25 ; pub const SHA3_224_DIGEST_SIZE : u32 = 28 ; pub const SHA3_224_BLOCK_SIZE : u32 = 144 ; pub const SHA3_256_DIGEST_SIZE : u32 = 32 ; pub const SHA3_256_BLOCK_SIZE : u32 = 136 ; pub const SHA3_384_DIGEST_SIZE : u32 = 48 ; pub const SHA3_384_BLOCK_SIZE : u32 = 104 ; pub const SHA3_512_DIGEST_SIZE : u32 = 64 ; pub const SHA3_512_BLOCK_SIZE : u32 = 72 ; pub const SHA3_224_DATA_SIZE : u32 = 144 ; pub const SHA3_256_DATA_SIZE : u32 = 136 ; pub const SHA3_384_DATA_SIZE : u32 = 104 ; pub const SHA3_512_DATA_SIZE : u32 = 72 ; pub const TWOFISH_BLOCK_SIZE : u32 = 16 ; pub const TWOFISH_MIN_KEY_SIZE : u32 = 16 ; pub const TWOFISH_MAX_KEY_SIZE : u32 = 32 ; pub const TWOFISH_KEY_SIZE : u32 = 32 ; pub const TWOFISH128_KEY_SIZE : u32 = 16 ; pub const TWOFISH192_KEY_SIZE : u32 = 24 ; pub const TWOFISH256_KEY_SIZE : u32 = 32 ; pub const UMAC_KEY_SIZE : u32 = 16 ; pub const UMAC32_DIGEST_SIZE : u32 = 4 ; pub const UMAC64_DIGEST_SIZE : u32 = 8 ; pub const UMAC96_DIGEST_SIZE : u32 = 12 ; pub const UMAC128_DIGEST_SIZE : u32 = 16 ; pub const UMAC_BLOCK_SIZE : u32 = 1024 ; pub const UMAC_MIN_NONCE_SIZE : u32 = 1 ; pub const UMAC_MAX_NONCE_SIZE : u32 = 16 ; pub const UMAC_DATA_SIZE : u32 = 1024 ; pub const _UMAC_NONCE_CACHED : u32 = 128 ; pub const UMAC_POLY64_BLOCKS : u32 = 16384 ; pub const UMAC_P64_OFFSET : u32 = 59 ; pub const UMAC_P128_OFFSET : u32 = 159 ; pub const YARROW256_SEED_FILE_SIZE : u32 = 32 ; pub const YARROW_KEY_EVENT_BUFFER : u32 = 16 ; pub type wchar_t = :: std :: os :: raw :: c_int ; pub type int_least8_t = i8 ; pub type int_least16_t = i16 ; pub type int_least32_t = i32 ; pub type int_least64_t = i64 ; pub type uint_least8_t = u8 ; pub type uint_least16_t = u16 ; pub type uint_least32_t = u32 ; pub type uint_least64_t = u64 ; pub type int_fast8_t = i8 ; pub type int_fast16_t = i16 ; pub type int_fast32_t = i32 ; pub type int_fast64_t = i64 ; pub type uint_fast8_t = u8 ; pub type uint_fast16_t = u16 ; pub type uint_fast32_t = u32 ; pub type uint_fast64_t = u64 ; pub type __int8_t = :: std :: os :: raw :: c_schar ; pub type __uint8_t = :: std :: os :: raw :: c_uchar ; pub type __int16_t = :: std :: os :: raw :: c_short ; pub type __uint16_t = :: std :: os :: raw :: c_ushort ; pub type __int32_t = :: std :: os :: raw :: c_int ; pub type __uint32_t = :: std :: os :: raw :: c_uint ; pub type __int64_t = :: std :: os :: raw :: c_longlong ; pub type __uint64_t = :: std :: os :: raw :: c_ulonglong ; pub type __darwin_intptr_t = :: std :: os :: raw :: c_long ; pub type __darwin_natural_t = :: std :: os :: raw :: c_uint ; pub type __darwin_ct_rune_t = :: std :: os :: raw :: c_int ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union __mbstate_t { pub __mbstate8 : [ :: std :: os :: raw :: c_char ; 128usize ] , pub _mbstateL : :: std :: os :: raw :: c_longlong , _bindgen_union_align : [ u64 ; 16usize ] , } # [ test ] fn bindgen_test_layout___mbstate_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __mbstate_t > ( ) , 128usize , concat ! ( "Size of: " , stringify ! ( __mbstate_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __mbstate_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __mbstate_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mbstate_t > ( ) ) ) . __mbstate8 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __mbstate_t ) , "::" , stringify ! ( __mbstate8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mbstate_t > ( ) ) ) . _mbstateL as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __mbstate_t ) , "::" , stringify ! ( _mbstateL ) ) ) ; } pub type __darwin_mbstate_t = __mbstate_t ; pub type __darwin_ptrdiff_t = :: std :: os :: raw :: c_long ; pub type __darwin_size_t = :: std :: os :: raw :: c_ulong ; pub type __darwin_va_list = __builtin_va_list ; pub type __darwin_wchar_t = :: std :: os :: raw :: c_int ; pub type __darwin_rune_t = __darwin_wchar_t ; pub type __darwin_wint_t = :: std :: os :: raw :: c_int ; pub type __darwin_clock_t = :: std :: os :: raw :: c_ulong ; pub type __darwin_socklen_t = __uint32_t ; pub type __darwin_ssize_t = :: std :: os :: raw :: c_long ; pub type __darwin_time_t = :: std :: os :: raw :: c_long ; pub type __darwin_blkcnt_t = __int64_t ; pub type __darwin_blksize_t = __int32_t ; pub type __darwin_dev_t = __int32_t ; pub type __darwin_fsblkcnt_t = :: std :: os :: raw :: c_uint ; pub type __darwin_fsfilcnt_t = :: std :: os :: raw :: c_uint ; pub type __darwin_gid_t = __uint32_t ; pub type __darwin_id_t = __uint32_t ; pub type __darwin_ino64_t = __uint64_t ; pub type __darwin_ino_t = __darwin_ino64_t ; pub type __darwin_mach_port_name_t = __darwin_natural_t ; pub type __darwin_mach_port_t = __darwin_mach_port_name_t ; pub type __darwin_mode_t = __uint16_t ; pub type __darwin_off_t = __int64_t ; pub type __darwin_pid_t = __int32_t ; pub type __darwin_sigset_t = __uint32_t ; pub type __darwin_suseconds_t = __int32_t ; pub type __darwin_uid_t = __uint32_t ; pub type __darwin_useconds_t = __uint32_t ; pub type __darwin_uuid_t = [ :: std :: os :: raw :: c_uchar ; 16usize ] ; pub type __darwin_uuid_string_t = [ :: std :: os :: raw :: c_char ; 37usize ] ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_pthread_handler_rec { pub __routine : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void ) > , pub __arg : * mut :: std :: os :: raw :: c_void , pub __next : * mut __darwin_pthread_handler_rec , } # [ test ] fn bindgen_test_layout___darwin_pthread_handler_rec ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_pthread_handler_rec > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( __darwin_pthread_handler_rec ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_pthread_handler_rec > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_pthread_handler_rec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_pthread_handler_rec > ( ) ) ) . __routine as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_pthread_handler_rec ) , "::" , stringify ! ( __routine ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_pthread_handler_rec > ( ) ) ) . __arg as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_pthread_handler_rec ) , "::" , stringify ! ( __arg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_pthread_handler_rec > ( ) ) ) . __next as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_pthread_handler_rec ) , "::" , stringify ! ( __next ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct _opaque_pthread_attr_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 56usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_attr_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_attr_t > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_attr_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_attr_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_attr_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_attr_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_attr_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_attr_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_attr_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct _opaque_pthread_cond_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 40usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_cond_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_cond_t > ( ) , 48usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_cond_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_cond_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_cond_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_cond_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_cond_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_cond_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_cond_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _opaque_pthread_condattr_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 8usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_condattr_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_condattr_t > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_condattr_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_condattr_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_condattr_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_condattr_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_condattr_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_condattr_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_condattr_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct _opaque_pthread_mutex_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 56usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_mutex_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_mutex_t > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_mutex_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_mutex_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_mutex_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_mutex_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_mutex_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_mutex_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_mutex_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _opaque_pthread_mutexattr_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 8usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_mutexattr_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_mutexattr_t > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_mutexattr_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_mutexattr_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_mutexattr_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_mutexattr_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_mutexattr_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_mutexattr_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_mutexattr_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _opaque_pthread_once_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 8usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_once_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_once_t > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_once_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_once_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_once_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_once_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_once_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_once_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_once_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct _opaque_pthread_rwlock_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 192usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_rwlock_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_rwlock_t > ( ) , 200usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_rwlock_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_rwlock_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_rwlock_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_rwlock_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_rwlock_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_rwlock_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_rwlock_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _opaque_pthread_rwlockattr_t { pub __sig : :: std :: os :: raw :: c_long , pub __opaque : [ :: std :: os :: raw :: c_char ; 16usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_rwlockattr_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_rwlockattr_t > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_rwlockattr_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_rwlockattr_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_rwlockattr_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_rwlockattr_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_rwlockattr_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_rwlockattr_t > ( ) ) ) . __opaque as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_rwlockattr_t ) , "::" , stringify ! ( __opaque ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct _opaque_pthread_t { pub __sig : :: std :: os :: raw :: c_long , pub __cleanup_stack : * mut __darwin_pthread_handler_rec , pub __opaque : [ :: std :: os :: raw :: c_char ; 8176usize ] , } # [ test ] fn bindgen_test_layout__opaque_pthread_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _opaque_pthread_t > ( ) , 8192usize , concat ! ( "Size of: " , stringify ! ( _opaque_pthread_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _opaque_pthread_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _opaque_pthread_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_t > ( ) ) ) . __sig as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_t ) , "::" , stringify ! ( __sig ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_t > ( ) ) ) . __cleanup_stack as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_t ) , "::" , stringify ! ( __cleanup_stack ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _opaque_pthread_t > ( ) ) ) . __opaque as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _opaque_pthread_t ) , "::" , stringify ! ( __opaque ) ) ) ; } pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t ; pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t ; pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t ; pub type __darwin_pthread_key_t = :: std :: os :: raw :: c_ulong ; pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t ; pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t ; pub type __darwin_pthread_once_t = _opaque_pthread_once_t ; pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t ; pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t ; pub type __darwin_pthread_t = * mut _opaque_pthread_t ; pub type u_int8_t = :: std :: os :: raw :: c_uchar ; pub type u_int16_t = :: std :: os :: raw :: c_ushort ; pub type u_int32_t = :: std :: os :: raw :: c_uint ; pub type u_int64_t = :: std :: os :: raw :: c_ulonglong ; pub type register_t = i64 ; pub type user_addr_t = u_int64_t ; pub type user_size_t = u_int64_t ; pub type user_ssize_t = i64 ; pub type user_long_t = i64 ; pub type user_ulong_t = u_int64_t ; pub type user_time_t = i64 ; pub type user_off_t = i64 ; pub type syscall_arg_t = u_int64_t ; pub type intmax_t = :: std :: os :: raw :: c_long ; pub type uintmax_t = :: std :: os :: raw :: c_ulong ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union nettle_block16 { pub b : [ u8 ; 16usize ] , pub w : [ :: std :: os :: raw :: c_ulong ; 2usize ] , _bindgen_union_align : [ u64 ; 2usize ] , } # [ test ] fn bindgen_test_layout_nettle_block16 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_block16 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( nettle_block16 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_block16 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_block16 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_block16 > ( ) ) ) . b as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_block16 ) , "::" , stringify ! ( b ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_block16 > ( ) ) ) . w as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_block16 ) , "::" , stringify ! ( w ) ) ) ; } pub type nettle_random_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , length : usize , dst : * mut u8 ) > ; pub type nettle_progress_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , c : :: std :: os :: raw :: c_int ) > ; pub type nettle_realloc_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , p : * mut :: std :: os :: raw :: c_void , length : usize ) -> * mut :: std :: os :: raw :: c_void > ; pub type nettle_set_key_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , key : * const u8 ) > ; pub type nettle_cipher_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * const :: std :: os :: raw :: c_void , length : usize , dst : * mut u8 , src : * const u8 ) > ; pub type nettle_crypt_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , length : usize , dst : * mut u8 , src : * const u8 ) > ; pub type nettle_hash_init_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void ) > ; pub type nettle_hash_update_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , length : usize , src : * const u8 ) > ; pub type nettle_hash_digest_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , length : usize , dst : * mut u8 ) > ; pub type nettle_armor_length_func = :: std :: option :: Option < unsafe extern "C" fn ( length : usize ) -> usize > ; pub type nettle_armor_init_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void ) > ; pub type nettle_armor_encode_update_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , dst : * mut :: std :: os :: raw :: c_char , src_length : usize , src : * const u8 ) -> usize > ; pub type nettle_armor_encode_final_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , dst : * mut :: std :: os :: raw :: c_char ) -> usize > ; pub type nettle_armor_decode_update_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void , dst_length : * mut usize , dst : * mut u8 , src_length : usize , src : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int > ; pub type nettle_armor_decode_final_func = :: std :: option :: Option < unsafe extern "C" fn ( ctx : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int > ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct aes_ctx { pub rounds : :: std :: os :: raw :: c_uint , pub keys : [ u32 ; 60usize ] , } # [ test ] fn bindgen_test_layout_aes_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < aes_ctx > ( ) , 244usize , concat ! ( "Size of: " , stringify ! ( aes_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < aes_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( aes_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < aes_ctx > ( ) ) ) . rounds as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( aes_ctx ) , "::" , stringify ! ( rounds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < aes_ctx > ( ) ) ) . keys as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( aes_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes_set_encrypt_key" ] pub fn nettle_aes_set_encrypt_key ( ctx : * mut aes_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes_set_decrypt_key" ] pub fn nettle_aes_set_decrypt_key ( ctx : * mut aes_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes_invert_key" ] pub fn nettle_aes_invert_key ( dst : * mut aes_ctx , src : * const aes_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes_encrypt" ] pub fn nettle_aes_encrypt ( ctx : * const aes_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes_decrypt" ] pub fn nettle_aes_decrypt ( ctx : * const aes_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct aes128_ctx { pub keys : [ u32 ; 44usize ] , } # [ test ] fn bindgen_test_layout_aes128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < aes128_ctx > ( ) , 176usize , concat ! ( "Size of: " , stringify ! ( aes128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < aes128_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( aes128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < aes128_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( aes128_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128_set_encrypt_key" ] pub fn nettle_aes128_set_encrypt_key ( ctx : * mut aes128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128_set_decrypt_key" ] pub fn nettle_aes128_set_decrypt_key ( ctx : * mut aes128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128_invert_key" ] pub fn nettle_aes128_invert_key ( dst : * mut aes128_ctx , src : * const aes128_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128_encrypt" ] pub fn nettle_aes128_encrypt ( ctx : * const aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128_decrypt" ] pub fn nettle_aes128_decrypt ( ctx : * const aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct aes192_ctx { pub keys : [ u32 ; 52usize ] , } # [ test ] fn bindgen_test_layout_aes192_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < aes192_ctx > ( ) , 208usize , concat ! ( "Size of: " , stringify ! ( aes192_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < aes192_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( aes192_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < aes192_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( aes192_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192_set_encrypt_key" ] pub fn nettle_aes192_set_encrypt_key ( ctx : * mut aes192_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192_set_decrypt_key" ] pub fn nettle_aes192_set_decrypt_key ( ctx : * mut aes192_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192_invert_key" ] pub fn nettle_aes192_invert_key ( dst : * mut aes192_ctx , src : * const aes192_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192_encrypt" ] pub fn nettle_aes192_encrypt ( ctx : * const aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192_decrypt" ] pub fn nettle_aes192_decrypt ( ctx : * const aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct aes256_ctx { pub keys : [ u32 ; 60usize ] , } # [ test ] fn bindgen_test_layout_aes256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < aes256_ctx > ( ) , 240usize , concat ! ( "Size of: " , stringify ! ( aes256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < aes256_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( aes256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < aes256_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( aes256_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256_set_encrypt_key" ] pub fn nettle_aes256_set_encrypt_key ( ctx : * mut aes256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256_set_decrypt_key" ] pub fn nettle_aes256_set_decrypt_key ( ctx : * mut aes256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256_invert_key" ] pub fn nettle_aes256_invert_key ( dst : * mut aes256_ctx , src : * const aes256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256_encrypt" ] pub fn nettle_aes256_encrypt ( ctx : * const aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256_decrypt" ] pub fn nettle_aes256_decrypt ( ctx : * const aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct arcfour_ctx { pub S : [ u8 ; 256usize ] , pub i : u8 , pub j : u8 , } # [ test ] fn bindgen_test_layout_arcfour_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < arcfour_ctx > ( ) , 258usize , concat ! ( "Size of: " , stringify ! ( arcfour_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < arcfour_ctx > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( arcfour_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < arcfour_ctx > ( ) ) ) . S as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( arcfour_ctx ) , "::" , stringify ! ( S ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < arcfour_ctx > ( ) ) ) . i as * const _ as usize } , 256usize , concat ! ( "Offset of field: " , stringify ! ( arcfour_ctx ) , "::" , stringify ! ( i ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < arcfour_ctx > ( ) ) ) . j as * const _ as usize } , 257usize , concat ! ( "Offset of field: " , stringify ! ( arcfour_ctx ) , "::" , stringify ! ( j ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arcfour_set_key" ] pub fn nettle_arcfour_set_key ( ctx : * mut arcfour_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arcfour128_set_key" ] pub fn nettle_arcfour128_set_key ( ctx : * mut arcfour_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arcfour_crypt" ] pub fn nettle_arcfour_crypt ( ctx : * mut arcfour_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct arctwo_ctx { pub S : [ u16 ; 64usize ] , } # [ test ] fn bindgen_test_layout_arctwo_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < arctwo_ctx > ( ) , 128usize , concat ! ( "Size of: " , stringify ! ( arctwo_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < arctwo_ctx > ( ) , 2usize , concat ! ( "Alignment of " , stringify ! ( arctwo_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < arctwo_ctx > ( ) ) ) . S as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( arctwo_ctx ) , "::" , stringify ! ( S ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_set_key_ekb" ] pub fn nettle_arctwo_set_key_ekb ( ctx : * mut arctwo_ctx , length : usize , key : * const u8 , ekb : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_set_key" ] pub fn nettle_arctwo_set_key ( ctx : * mut arctwo_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo40_set_key" ] pub fn nettle_arctwo40_set_key ( ctx : * mut arctwo_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo64_set_key" ] pub fn nettle_arctwo64_set_key ( ctx : * mut arctwo_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo128_set_key" ] pub fn nettle_arctwo128_set_key ( ctx : * mut arctwo_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_set_key_gutmann" ] pub fn nettle_arctwo_set_key_gutmann ( ctx : * mut arctwo_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo128_set_key_gutmann" ] pub fn nettle_arctwo128_set_key_gutmann ( ctx : * mut arctwo_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_encrypt" ] pub fn nettle_arctwo_encrypt ( ctx : * mut arctwo_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_decrypt" ] pub fn nettle_arctwo_decrypt ( ctx : * mut arctwo_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } pub const ASN1_TYPE_CONSTRUCTED : _bindgen_ty_1 = 4096 ; pub const ASN1_CLASS_UNIVERSAL : _bindgen_ty_1 = 0 ; pub const ASN1_CLASS_APPLICATION : _bindgen_ty_1 = 8192 ; pub const ASN1_CLASS_CONTEXT_SPECIFIC : _bindgen_ty_1 = 16384 ; pub const ASN1_CLASS_PRIVATE : _bindgen_ty_1 = 24576 ; pub const ASN1_CLASS_MASK : _bindgen_ty_1 = 24576 ; pub const ASN1_CLASS_SHIFT : _bindgen_ty_1 = 13 ; pub type _bindgen_ty_1 = u32 ; pub const asn1_type_ASN1_BOOLEAN : asn1_type = 1 ; pub const asn1_type_ASN1_INTEGER : asn1_type = 2 ; pub const asn1_type_ASN1_BITSTRING : asn1_type = 3 ; pub const asn1_type_ASN1_OCTETSTRING : asn1_type = 4 ; pub const asn1_type_ASN1_NULL : asn1_type = 5 ; pub const asn1_type_ASN1_IDENTIFIER : asn1_type = 6 ; pub const asn1_type_ASN1_REAL : asn1_type = 9 ; pub const asn1_type_ASN1_ENUMERATED : asn1_type = 10 ; pub const asn1_type_ASN1_UTF8STRING : asn1_type = 12 ; pub const asn1_type_ASN1_SEQUENCE : asn1_type = 4112 ; pub const asn1_type_ASN1_SET : asn1_type = 4113 ; pub const asn1_type_ASN1_PRINTABLESTRING : asn1_type = 19 ; pub const asn1_type_ASN1_TELETEXSTRING : asn1_type = 20 ; pub const asn1_type_ASN1_IA5STRING : asn1_type = 22 ; pub const asn1_type_ASN1_UTC : asn1_type = 23 ; pub const asn1_type_ASN1_UNIVERSALSTRING : asn1_type = 28 ; pub const asn1_type_ASN1_BMPSTRING : asn1_type = 30 ; pub type asn1_type = u32 ; pub const asn1_iterator_result_ASN1_ITERATOR_ERROR : asn1_iterator_result = 0 ; pub const asn1_iterator_result_ASN1_ITERATOR_PRIMITIVE : asn1_iterator_result = 1 ; pub const asn1_iterator_result_ASN1_ITERATOR_CONSTRUCTED : asn1_iterator_result = 2 ; pub const asn1_iterator_result_ASN1_ITERATOR_END : asn1_iterator_result = 3 ; pub type asn1_iterator_result = u32 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct asn1_der_iterator { pub buffer_length : usize , pub buffer : * const u8 , pub pos : usize , pub type_ : asn1_type , pub length : usize , pub data : * const u8 , } # [ test ] fn bindgen_test_layout_asn1_der_iterator ( ) { assert_eq ! ( :: std :: mem :: size_of :: < asn1_der_iterator > ( ) , 48usize , concat ! ( "Size of: " , stringify ! ( asn1_der_iterator ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < asn1_der_iterator > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( asn1_der_iterator ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . buffer_length as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( buffer_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . buffer as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( buffer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . pos as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( pos ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . type_ as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . length as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < asn1_der_iterator > ( ) ) ) . data as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( asn1_der_iterator ) , "::" , stringify ! ( data ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_iterator_first" ] pub fn nettle_asn1_der_iterator_first ( iterator : * mut asn1_der_iterator , length : usize , input : * const u8 ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_iterator_next" ] pub fn nettle_asn1_der_iterator_next ( iterator : * mut asn1_der_iterator ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_decode_constructed" ] pub fn nettle_asn1_der_decode_constructed ( i : * mut asn1_der_iterator , contents : * mut asn1_der_iterator ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_decode_constructed_last" ] pub fn nettle_asn1_der_decode_constructed_last ( i : * mut asn1_der_iterator ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_decode_bitstring" ] pub fn nettle_asn1_der_decode_bitstring ( i : * mut asn1_der_iterator , contents : * mut asn1_der_iterator ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_decode_bitstring_last" ] pub fn nettle_asn1_der_decode_bitstring_last ( i : * mut asn1_der_iterator ) -> asn1_iterator_result ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_get_uint32" ] pub fn nettle_asn1_der_get_uint32 ( i : * mut asn1_der_iterator , x : * mut u32 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_encode_single" ] pub fn nettle_base16_encode_single ( dst : * mut :: std :: os :: raw :: c_char , src : u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_encode_update" ] pub fn nettle_base16_encode_update ( dst : * mut :: std :: os :: raw :: c_char , length : usize , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct base16_decode_ctx { pub word : :: std :: os :: raw :: c_uchar , pub bits : :: std :: os :: raw :: c_uchar , } # [ test ] fn bindgen_test_layout_base16_decode_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < base16_decode_ctx > ( ) , 2usize , concat ! ( "Size of: " , stringify ! ( base16_decode_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < base16_decode_ctx > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( base16_decode_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base16_decode_ctx > ( ) ) ) . word as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( base16_decode_ctx ) , "::" , stringify ! ( word ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base16_decode_ctx > ( ) ) ) . bits as * const _ as usize } , 1usize , concat ! ( "Offset of field: " , stringify ! ( base16_decode_ctx ) , "::" , stringify ! ( bits ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_decode_init" ] pub fn nettle_base16_decode_init ( ctx : * mut base16_decode_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_decode_single" ] pub fn nettle_base16_decode_single ( ctx : * mut base16_decode_ctx , dst : * mut u8 , src : :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_decode_update" ] pub fn nettle_base16_decode_update ( ctx : * mut base16_decode_ctx , dst_length : * mut usize , dst : * mut u8 , src_length : usize , src : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_base16_decode_final" ] pub fn nettle_base16_decode_final ( ctx : * mut base16_decode_ctx ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct base64_encode_ctx { pub alphabet : * const :: std :: os :: raw :: c_char , pub word : :: std :: os :: raw :: c_ushort , pub bits : :: std :: os :: raw :: c_uchar , } # [ test ] fn bindgen_test_layout_base64_encode_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < base64_encode_ctx > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( base64_encode_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < base64_encode_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( base64_encode_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_encode_ctx > ( ) ) ) . alphabet as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( base64_encode_ctx ) , "::" , stringify ! ( alphabet ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_encode_ctx > ( ) ) ) . word as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( base64_encode_ctx ) , "::" , stringify ! ( word ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_encode_ctx > ( ) ) ) . bits as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( base64_encode_ctx ) , "::" , stringify ! ( bits ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_init" ] pub fn nettle_base64_encode_init ( ctx : * mut base64_encode_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64url_encode_init" ] pub fn nettle_base64url_encode_init ( ctx : * mut base64_encode_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_single" ] pub fn nettle_base64_encode_single ( ctx : * mut base64_encode_ctx , dst : * mut :: std :: os :: raw :: c_char , src : u8 ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_update" ] pub fn nettle_base64_encode_update ( ctx : * mut base64_encode_ctx , dst : * mut :: std :: os :: raw :: c_char , length : usize , src : * const u8 ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_final" ] pub fn nettle_base64_encode_final ( ctx : * mut base64_encode_ctx , dst : * mut :: std :: os :: raw :: c_char ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_raw" ] pub fn nettle_base64_encode_raw ( dst : * mut :: std :: os :: raw :: c_char , length : usize , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_encode_group" ] pub fn nettle_base64_encode_group ( dst : * mut :: std :: os :: raw :: c_char , group : u32 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct base64_decode_ctx { pub table : * const :: std :: os :: raw :: c_schar , pub word : :: std :: os :: raw :: c_ushort , pub bits : :: std :: os :: raw :: c_uchar , pub padding : :: std :: os :: raw :: c_uchar , } # [ test ] fn bindgen_test_layout_base64_decode_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < base64_decode_ctx > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( base64_decode_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < base64_decode_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( base64_decode_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_decode_ctx > ( ) ) ) . table as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( base64_decode_ctx ) , "::" , stringify ! ( table ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_decode_ctx > ( ) ) ) . word as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( base64_decode_ctx ) , "::" , stringify ! ( word ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_decode_ctx > ( ) ) ) . bits as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( base64_decode_ctx ) , "::" , stringify ! ( bits ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < base64_decode_ctx > ( ) ) ) . padding as * const _ as usize } , 11usize , concat ! ( "Offset of field: " , stringify ! ( base64_decode_ctx ) , "::" , stringify ! ( padding ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_decode_init" ] pub fn nettle_base64_decode_init ( ctx : * mut base64_decode_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64url_decode_init" ] pub fn nettle_base64url_decode_init ( ctx : * mut base64_decode_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_decode_single" ] pub fn nettle_base64_decode_single ( ctx : * mut base64_decode_ctx , dst : * mut u8 , src : :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_decode_update" ] pub fn nettle_base64_decode_update ( ctx : * mut base64_decode_ctx , dst_length : * mut usize , dst : * mut u8 , src_length : usize , src : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_base64_decode_final" ] pub fn nettle_base64_decode_final ( ctx : * mut base64_decode_ctx ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct nettle_cipher { pub name : * const :: std :: os :: raw :: c_char , pub context_size : :: std :: os :: raw :: c_uint , pub block_size : :: std :: os :: raw :: c_uint , pub key_size : :: std :: os :: raw :: c_uint , pub set_encrypt_key : nettle_set_key_func , pub set_decrypt_key : nettle_set_key_func , pub encrypt : nettle_cipher_func , pub decrypt : nettle_cipher_func , } # [ test ] fn bindgen_test_layout_nettle_cipher ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_cipher > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( nettle_cipher ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_cipher > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_cipher ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . context_size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( context_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . block_size as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( block_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . key_size as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( key_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . set_encrypt_key as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( set_encrypt_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . set_decrypt_key as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( set_decrypt_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . encrypt as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( encrypt ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_cipher > ( ) ) ) . decrypt as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( nettle_cipher ) , "::" , stringify ! ( decrypt ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ciphers" ] pub static mut nettle_ciphers : [ * const nettle_cipher ; 0usize ] ; } extern "C" { # [ link_name = "\u{1}_nettle_get_ciphers" ] pub fn nettle_get_ciphers ( ) -> * const * const nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_aes128" ] pub static nettle_aes128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_aes192" ] pub static nettle_aes192 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_aes256" ] pub static nettle_aes256 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia128" ] pub static nettle_camellia128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia192" ] pub static nettle_camellia192 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia256" ] pub static nettle_camellia256 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_cast128" ] pub static nettle_cast128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent128" ] pub static nettle_serpent128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent192" ] pub static nettle_serpent192 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent256" ] pub static nettle_serpent256 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish128" ] pub static nettle_twofish128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish192" ] pub static nettle_twofish192 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish256" ] pub static nettle_twofish256 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo40" ] pub static nettle_arctwo40 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo64" ] pub static nettle_arctwo64 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo128" ] pub static nettle_arctwo128 : nettle_cipher ; } extern "C" { # [ link_name = "\u{1}_nettle_arctwo_gutmann128" ] pub static nettle_arctwo_gutmann128 : nettle_cipher ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct nettle_hash { pub name : * const :: std :: os :: raw :: c_char , pub context_size : :: std :: os :: raw :: c_uint , pub digest_size : :: std :: os :: raw :: c_uint , pub block_size : :: std :: os :: raw :: c_uint , pub init : nettle_hash_init_func , pub update : nettle_hash_update_func , pub digest : nettle_hash_digest_func , } # [ test ] fn bindgen_test_layout_nettle_hash ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_hash > ( ) , 48usize , concat ! ( "Size of: " , stringify ! ( nettle_hash ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_hash > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_hash ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . context_size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( context_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . digest_size as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( digest_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . block_size as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( block_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . init as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( init ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . update as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_hash > ( ) ) ) . digest as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( nettle_hash ) , "::" , stringify ! ( digest ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hashes" ] pub static mut nettle_hashes : [ * const nettle_hash ; 0usize ] ; } extern "C" { # [ link_name = "\u{1}_nettle_get_hashes" ] pub fn nettle_get_hashes ( ) -> * const * const nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_lookup_hash" ] pub fn nettle_lookup_hash ( name : * const :: std :: os :: raw :: c_char ) -> * const nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_md2" ] pub static nettle_md2 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_md4" ] pub static nettle_md4 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_md5" ] pub static nettle_md5 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_gosthash94" ] pub static nettle_gosthash94 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_ripemd160" ] pub static nettle_ripemd160 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha1" ] pub static nettle_sha1 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha224" ] pub static nettle_sha224 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha256" ] pub static nettle_sha256 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha384" ] pub static nettle_sha384 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512" ] pub static nettle_sha512 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_224" ] pub static nettle_sha512_224 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_256" ] pub static nettle_sha512_256 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_224" ] pub static nettle_sha3_224 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_256" ] pub static nettle_sha3_256 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_384" ] pub static nettle_sha3_384 : nettle_hash ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_512" ] pub static nettle_sha3_512 : nettle_hash ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct nettle_aead { pub name : * const :: std :: os :: raw :: c_char , pub context_size : :: std :: os :: raw :: c_uint , pub block_size : :: std :: os :: raw :: c_uint , pub key_size : :: std :: os :: raw :: c_uint , pub nonce_size : :: std :: os :: raw :: c_uint , pub digest_size : :: std :: os :: raw :: c_uint , pub set_encrypt_key : nettle_set_key_func , pub set_decrypt_key : nettle_set_key_func , pub set_nonce : nettle_set_key_func , pub update : nettle_hash_update_func , pub encrypt : nettle_crypt_func , pub decrypt : nettle_crypt_func , pub digest : nettle_hash_digest_func , } # [ test ] fn bindgen_test_layout_nettle_aead ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_aead > ( ) , 88usize , concat ! ( "Size of: " , stringify ! ( nettle_aead ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_aead > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_aead ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . context_size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( context_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . block_size as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( block_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . key_size as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( key_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . nonce_size as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( nonce_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . digest_size as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( digest_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . set_encrypt_key as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( set_encrypt_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . set_decrypt_key as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( set_decrypt_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . set_nonce as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( set_nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . update as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . encrypt as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( encrypt ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . decrypt as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( decrypt ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_aead > ( ) ) ) . digest as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( nettle_aead ) , "::" , stringify ! ( digest ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_aeads" ] pub static mut nettle_aeads : [ * const nettle_aead ; 0usize ] ; } extern "C" { # [ link_name = "\u{1}_nettle_get_aeads" ] pub fn nettle_get_aeads ( ) -> * const * const nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128" ] pub static nettle_gcm_aes128 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192" ] pub static nettle_gcm_aes192 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256" ] pub static nettle_gcm_aes256 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128" ] pub static nettle_gcm_camellia128 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256" ] pub static nettle_gcm_camellia256 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128" ] pub static nettle_eax_aes128 : nettle_aead ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305" ] pub static nettle_chacha_poly1305 : nettle_aead ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct nettle_armor { pub name : * const :: std :: os :: raw :: c_char , pub encode_context_size : :: std :: os :: raw :: c_uint , pub decode_context_size : :: std :: os :: raw :: c_uint , pub encode_final_length : :: std :: os :: raw :: c_uint , pub encode_init : nettle_armor_init_func , pub encode_length : nettle_armor_length_func , pub encode_update : nettle_armor_encode_update_func , pub encode_final : nettle_armor_encode_final_func , pub decode_init : nettle_armor_init_func , pub decode_length : nettle_armor_length_func , pub decode_update : nettle_armor_decode_update_func , pub decode_final : nettle_armor_decode_final_func , } # [ test ] fn bindgen_test_layout_nettle_armor ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_armor > ( ) , 88usize , concat ! ( "Size of: " , stringify ! ( nettle_armor ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_armor > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_armor ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . name as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_context_size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_context_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . decode_context_size as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( decode_context_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_final_length as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_final_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_init as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_init ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_length as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_update as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . encode_final as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( encode_final ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . decode_init as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( decode_init ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . decode_length as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( decode_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . decode_update as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( decode_update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_armor > ( ) ) ) . decode_final as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( nettle_armor ) , "::" , stringify ! ( decode_final ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_armors" ] pub static mut nettle_armors : [ * const nettle_armor ; 0usize ] ; } extern "C" { # [ link_name = "\u{1}_nettle_get_armors" ] pub fn nettle_get_armors ( ) -> * const * const nettle_armor ; } extern "C" { # [ link_name = "\u{1}_nettle_base64" ] pub static nettle_base64 : nettle_armor ; } extern "C" { # [ link_name = "\u{1}_nettle_base64url" ] pub static nettle_base64url : nettle_armor ; } extern "C" { # [ link_name = "\u{1}_nettle_base16" ] pub static nettle_base16 : nettle_armor ; } extern "C" { # [ link_name = "\u{1}_nettle_version_major" ] pub fn nettle_version_major ( ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_version_minor" ] pub fn nettle_version_minor ( ) -> :: std :: os :: raw :: c_int ; } pub type mp_limb_t = :: std :: os :: raw :: c_ulong ; pub type mp_limb_signed_t = :: std :: os :: raw :: c_long ; pub type mp_bitcnt_t = :: std :: os :: raw :: c_ulong ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __mpz_struct { pub _mp_alloc : :: std :: os :: raw :: c_int , pub _mp_size : :: std :: os :: raw :: c_int , pub _mp_d : * mut mp_limb_t , } # [ test ] fn bindgen_test_layout___mpz_struct ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __mpz_struct > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( __mpz_struct ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __mpz_struct > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __mpz_struct ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpz_struct > ( ) ) ) . _mp_alloc as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __mpz_struct ) , "::" , stringify ! ( _mp_alloc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpz_struct > ( ) ) ) . _mp_size as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __mpz_struct ) , "::" , stringify ! ( _mp_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpz_struct > ( ) ) ) . _mp_d as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __mpz_struct ) , "::" , stringify ! ( _mp_d ) ) ) ; } pub type MP_INT = __mpz_struct ; pub type mpz_t = [ __mpz_struct ; 1usize ] ; pub type mp_ptr = * mut mp_limb_t ; pub type mp_srcptr = * const mp_limb_t ; pub type mp_size_t = :: std :: os :: raw :: c_long ; pub type mp_exp_t = :: std :: os :: raw :: c_long ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __mpq_struct { pub _mp_num : __mpz_struct , pub _mp_den : __mpz_struct , } # [ test ] fn bindgen_test_layout___mpq_struct ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __mpq_struct > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( __mpq_struct ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __mpq_struct > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __mpq_struct ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpq_struct > ( ) ) ) . _mp_num as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __mpq_struct ) , "::" , stringify ! ( _mp_num ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpq_struct > ( ) ) ) . _mp_den as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __mpq_struct ) , "::" , stringify ! ( _mp_den ) ) ) ; } pub type MP_RAT = __mpq_struct ; pub type mpq_t = [ __mpq_struct ; 1usize ] ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __mpf_struct { pub _mp_prec : :: std :: os :: raw :: c_int , pub _mp_size : :: std :: os :: raw :: c_int , pub _mp_exp : mp_exp_t , pub _mp_d : * mut mp_limb_t , } # [ test ] fn bindgen_test_layout___mpf_struct ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __mpf_struct > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( __mpf_struct ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __mpf_struct > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __mpf_struct ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpf_struct > ( ) ) ) . _mp_prec as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __mpf_struct ) , "::" , stringify ! ( _mp_prec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpf_struct > ( ) ) ) . _mp_size as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __mpf_struct ) , "::" , stringify ! ( _mp_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpf_struct > ( ) ) ) . _mp_exp as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __mpf_struct ) , "::" , stringify ! ( _mp_exp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __mpf_struct > ( ) ) ) . _mp_d as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __mpf_struct ) , "::" , stringify ! ( _mp_d ) ) ) ; } pub type mpf_t = [ __mpf_struct ; 1usize ] ; pub const gmp_randalg_t_GMP_RAND_ALG_DEFAULT : gmp_randalg_t = 0 ; pub const gmp_randalg_t_GMP_RAND_ALG_LC : gmp_randalg_t = 0 ; pub type gmp_randalg_t = u32 ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __gmp_randstate_struct { pub _mp_seed : mpz_t , pub _mp_alg : gmp_randalg_t , pub _mp_algdata : __gmp_randstate_struct__bindgen_ty_1 , } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union __gmp_randstate_struct__bindgen_ty_1 { pub _mp_lc : * mut :: std :: os :: raw :: c_void , _bindgen_union_align : u64 , } # [ test ] fn bindgen_test_layout___gmp_randstate_struct__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __gmp_randstate_struct__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( __gmp_randstate_struct__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __gmp_randstate_struct__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __gmp_randstate_struct__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __gmp_randstate_struct__bindgen_ty_1 > ( ) ) ) . _mp_lc as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __gmp_randstate_struct__bindgen_ty_1 ) , "::" , stringify ! ( _mp_lc ) ) ) ; } # [ test ] fn bindgen_test_layout___gmp_randstate_struct ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __gmp_randstate_struct > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( __gmp_randstate_struct ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __gmp_randstate_struct > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __gmp_randstate_struct ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __gmp_randstate_struct > ( ) ) ) . _mp_seed as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __gmp_randstate_struct ) , "::" , stringify ! ( _mp_seed ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __gmp_randstate_struct > ( ) ) ) . _mp_alg as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __gmp_randstate_struct ) , "::" , stringify ! ( _mp_alg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __gmp_randstate_struct > ( ) ) ) . _mp_algdata as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __gmp_randstate_struct ) , "::" , stringify ! ( _mp_algdata ) ) ) ; } pub type gmp_randstate_t = [ __gmp_randstate_struct ; 1usize ] ; pub type mpz_srcptr = * const __mpz_struct ; pub type mpz_ptr = * mut __mpz_struct ; pub type mpf_srcptr = * const __mpf_struct ; pub type mpf_ptr = * mut __mpf_struct ; pub type mpq_srcptr = * const __mpq_struct ; pub type mpq_ptr = * mut __mpq_struct ; extern "C" { # [ link_name = "\u{1}___gmp_set_memory_functions" ] pub fn __gmp_set_memory_functions ( arg1 : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : usize ) -> * mut :: std :: os :: raw :: c_void > , arg2 : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : usize , arg3 : usize ) -> * mut :: std :: os :: raw :: c_void > , arg3 : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : usize ) > ) ; } extern "C" { # [ link_name = "\u{1}___gmp_get_memory_functions" ] pub fn __gmp_get_memory_functions ( arg1 : * mut :: std :: option :: Option < unsafe extern "C" fn ( arg1 : usize ) -> * mut :: std :: os :: raw :: c_void > , arg2 : * mut :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : usize , arg3 : usize ) -> * mut :: std :: os :: raw :: c_void > , arg3 : * mut :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : usize ) > ) ; } extern "C" { # [ link_name = "\u{1}___gmp_bits_per_limb" ] pub static __gmp_bits_per_limb : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_errno" ] pub static mut __gmp_errno : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_version" ] pub static __gmp_version : * const :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit" ] pub fn __gmp_randinit ( arg1 : * mut __gmp_randstate_struct , arg2 : gmp_randalg_t , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit_default" ] pub fn __gmp_randinit_default ( arg1 : * mut __gmp_randstate_struct ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit_lc_2exp" ] pub fn __gmp_randinit_lc_2exp ( arg1 : * mut __gmp_randstate_struct , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong , arg4 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit_lc_2exp_size" ] pub fn __gmp_randinit_lc_2exp_size ( arg1 : * mut __gmp_randstate_struct , arg2 : mp_bitcnt_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit_mt" ] pub fn __gmp_randinit_mt ( arg1 : * mut __gmp_randstate_struct ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randinit_set" ] pub fn __gmp_randinit_set ( arg1 : * mut __gmp_randstate_struct , arg2 : * const __gmp_randstate_struct ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randseed" ] pub fn __gmp_randseed ( arg1 : * mut __gmp_randstate_struct , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randseed_ui" ] pub fn __gmp_randseed_ui ( arg1 : * mut __gmp_randstate_struct , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmp_randclear" ] pub fn __gmp_randclear ( arg1 : * mut __gmp_randstate_struct ) ; } extern "C" { # [ link_name = "\u{1}___gmp_urandomb_ui" ] pub fn __gmp_urandomb_ui ( arg1 : * mut __gmp_randstate_struct , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmp_urandomm_ui" ] pub fn __gmp_urandomm_ui ( arg1 : * mut __gmp_randstate_struct , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmp_asprintf" ] pub fn __gmp_asprintf ( arg1 : * mut * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_printf" ] pub fn __gmp_printf ( arg1 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_snprintf" ] pub fn __gmp_snprintf ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : usize , arg3 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_sprintf" ] pub fn __gmp_sprintf ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_scanf" ] pub fn __gmp_scanf ( arg1 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmp_sscanf" ] pub fn __gmp_sscanf ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , ... ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_realloc" ] pub fn __gmpz_realloc ( arg1 : mpz_ptr , arg2 : mp_size_t ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}___gmpz_abs" ] pub fn __gmpz_abs ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_add" ] pub fn __gmpz_add ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_add_ui" ] pub fn __gmpz_add_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_addmul" ] pub fn __gmpz_addmul ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_addmul_ui" ] pub fn __gmpz_addmul_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_and" ] pub fn __gmpz_and ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_array_init" ] pub fn __gmpz_array_init ( arg1 : mpz_ptr , arg2 : mp_size_t , arg3 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_bin_ui" ] pub fn __gmpz_bin_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_bin_uiui" ] pub fn __gmpz_bin_uiui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_q" ] pub fn __gmpz_cdiv_q ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_q_2exp" ] pub fn __gmpz_cdiv_q_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_q_ui" ] pub fn __gmpz_cdiv_q_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_qr" ] pub fn __gmpz_cdiv_qr ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_qr_ui" ] pub fn __gmpz_cdiv_qr_ui ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_r" ] pub fn __gmpz_cdiv_r ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_r_2exp" ] pub fn __gmpz_cdiv_r_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_r_ui" ] pub fn __gmpz_cdiv_r_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_cdiv_ui" ] pub fn __gmpz_cdiv_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_clear" ] pub fn __gmpz_clear ( arg1 : mpz_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_clears" ] pub fn __gmpz_clears ( arg1 : mpz_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_clrbit" ] pub fn __gmpz_clrbit ( arg1 : mpz_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmp" ] pub fn __gmpz_cmp ( arg1 : mpz_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmp_d" ] pub fn __gmpz_cmp_d ( arg1 : mpz_srcptr , arg2 : f64 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmp_si" ] pub fn __gmpz_cmp_si ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_long ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmp_ui" ] pub fn __gmpz_cmp_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmpabs" ] pub fn __gmpz_cmpabs ( arg1 : mpz_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmpabs_d" ] pub fn __gmpz_cmpabs_d ( arg1 : mpz_srcptr , arg2 : f64 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_cmpabs_ui" ] pub fn __gmpz_cmpabs_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_com" ] pub fn __gmpz_com ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_combit" ] pub fn __gmpz_combit ( arg1 : mpz_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_congruent_p" ] pub fn __gmpz_congruent_p ( arg1 : mpz_srcptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_congruent_2exp_p" ] pub fn __gmpz_congruent_2exp_p ( arg1 : mpz_srcptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_congruent_ui_p" ] pub fn __gmpz_congruent_ui_p ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_divexact" ] pub fn __gmpz_divexact ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_divexact_ui" ] pub fn __gmpz_divexact_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_divisible_p" ] pub fn __gmpz_divisible_p ( arg1 : mpz_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_divisible_ui_p" ] pub fn __gmpz_divisible_ui_p ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_divisible_2exp_p" ] pub fn __gmpz_divisible_2exp_p ( arg1 : mpz_srcptr , arg2 : mp_bitcnt_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_dump" ] pub fn __gmpz_dump ( arg1 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_export" ] pub fn __gmpz_export ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : * mut usize , arg3 : :: std :: os :: raw :: c_int , arg4 : usize , arg5 : :: std :: os :: raw :: c_int , arg6 : usize , arg7 : mpz_srcptr ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}___gmpz_fac_ui" ] pub fn __gmpz_fac_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_2fac_ui" ] pub fn __gmpz_2fac_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_mfac_uiui" ] pub fn __gmpz_mfac_uiui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_primorial_ui" ] pub fn __gmpz_primorial_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_q" ] pub fn __gmpz_fdiv_q ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_q_2exp" ] pub fn __gmpz_fdiv_q_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_q_ui" ] pub fn __gmpz_fdiv_q_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_qr" ] pub fn __gmpz_fdiv_qr ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_qr_ui" ] pub fn __gmpz_fdiv_qr_ui ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_r" ] pub fn __gmpz_fdiv_r ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_r_2exp" ] pub fn __gmpz_fdiv_r_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_r_ui" ] pub fn __gmpz_fdiv_r_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_fdiv_ui" ] pub fn __gmpz_fdiv_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_fib_ui" ] pub fn __gmpz_fib_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fib2_ui" ] pub fn __gmpz_fib2_ui ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_sint_p" ] pub fn __gmpz_fits_sint_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_slong_p" ] pub fn __gmpz_fits_slong_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_sshort_p" ] pub fn __gmpz_fits_sshort_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_uint_p" ] pub fn __gmpz_fits_uint_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_ulong_p" ] pub fn __gmpz_fits_ulong_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_fits_ushort_p" ] pub fn __gmpz_fits_ushort_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_gcd" ] pub fn __gmpz_gcd ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_gcd_ui" ] pub fn __gmpz_gcd_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_gcdext" ] pub fn __gmpz_gcdext ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_ptr , arg4 : mpz_srcptr , arg5 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_get_d" ] pub fn __gmpz_get_d ( arg1 : mpz_srcptr ) -> f64 ; } extern "C" { # [ link_name = "\u{1}___gmpz_get_d_2exp" ] pub fn __gmpz_get_d_2exp ( arg1 : * mut :: std :: os :: raw :: c_long , arg2 : mpz_srcptr ) -> f64 ; } extern "C" { # [ link_name = "\u{1}___gmpz_get_si" ] pub fn __gmpz_get_si ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}___gmpz_get_str" ] pub fn __gmpz_get_str ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : :: std :: os :: raw :: c_int , arg3 : mpz_srcptr ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}___gmpz_get_ui" ] pub fn __gmpz_get_ui ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_getlimbn" ] pub fn __gmpz_getlimbn ( arg1 : mpz_srcptr , arg2 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_hamdist" ] pub fn __gmpz_hamdist ( arg1 : mpz_srcptr , arg2 : mpz_srcptr ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_import" ] pub fn __gmpz_import ( arg1 : mpz_ptr , arg2 : usize , arg3 : :: std :: os :: raw :: c_int , arg4 : usize , arg5 : :: std :: os :: raw :: c_int , arg6 : usize , arg7 : * const :: std :: os :: raw :: c_void ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init" ] pub fn __gmpz_init ( arg1 : mpz_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init2" ] pub fn __gmpz_init2 ( arg1 : mpz_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_inits" ] pub fn __gmpz_inits ( arg1 : mpz_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init_set" ] pub fn __gmpz_init_set ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init_set_d" ] pub fn __gmpz_init_set_d ( arg1 : mpz_ptr , arg2 : f64 ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init_set_si" ] pub fn __gmpz_init_set_si ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_init_set_str" ] pub fn __gmpz_init_set_str ( arg1 : mpz_ptr , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_init_set_ui" ] pub fn __gmpz_init_set_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_invert" ] pub fn __gmpz_invert ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_ior" ] pub fn __gmpz_ior ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_jacobi" ] pub fn __gmpz_jacobi ( arg1 : mpz_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_kronecker_si" ] pub fn __gmpz_kronecker_si ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_long ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_kronecker_ui" ] pub fn __gmpz_kronecker_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_si_kronecker" ] pub fn __gmpz_si_kronecker ( arg1 : :: std :: os :: raw :: c_long , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_ui_kronecker" ] pub fn __gmpz_ui_kronecker ( arg1 : :: std :: os :: raw :: c_ulong , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_lcm" ] pub fn __gmpz_lcm ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_lcm_ui" ] pub fn __gmpz_lcm_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_lucnum_ui" ] pub fn __gmpz_lucnum_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_lucnum2_ui" ] pub fn __gmpz_lucnum2_ui ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_millerrabin" ] pub fn __gmpz_millerrabin ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_mod" ] pub fn __gmpz_mod ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_mul" ] pub fn __gmpz_mul ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_mul_2exp" ] pub fn __gmpz_mul_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_mul_si" ] pub fn __gmpz_mul_si ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_mul_ui" ] pub fn __gmpz_mul_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_neg" ] pub fn __gmpz_neg ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_nextprime" ] pub fn __gmpz_nextprime ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_perfect_power_p" ] pub fn __gmpz_perfect_power_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_perfect_square_p" ] pub fn __gmpz_perfect_square_p ( arg1 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_popcount" ] pub fn __gmpz_popcount ( arg1 : mpz_srcptr ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_pow_ui" ] pub fn __gmpz_pow_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_powm" ] pub fn __gmpz_powm ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_powm_sec" ] pub fn __gmpz_powm_sec ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_powm_ui" ] pub fn __gmpz_powm_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_probab_prime_p" ] pub fn __gmpz_probab_prime_p ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_random" ] pub fn __gmpz_random ( arg1 : mpz_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_random2" ] pub fn __gmpz_random2 ( arg1 : mpz_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_realloc2" ] pub fn __gmpz_realloc2 ( arg1 : mpz_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_remove" ] pub fn __gmpz_remove ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_root" ] pub fn __gmpz_root ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_rootrem" ] pub fn __gmpz_rootrem ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_rrandomb" ] pub fn __gmpz_rrandomb ( arg1 : mpz_ptr , arg2 : * mut __gmp_randstate_struct , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_scan0" ] pub fn __gmpz_scan0 ( arg1 : mpz_srcptr , arg2 : mp_bitcnt_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_scan1" ] pub fn __gmpz_scan1 ( arg1 : mpz_srcptr , arg2 : mp_bitcnt_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpz_set" ] pub fn __gmpz_set ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_d" ] pub fn __gmpz_set_d ( arg1 : mpz_ptr , arg2 : f64 ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_f" ] pub fn __gmpz_set_f ( arg1 : mpz_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_q" ] pub fn __gmpz_set_q ( arg1 : mpz_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_si" ] pub fn __gmpz_set_si ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_str" ] pub fn __gmpz_set_str ( arg1 : mpz_ptr , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_set_ui" ] pub fn __gmpz_set_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_setbit" ] pub fn __gmpz_setbit ( arg1 : mpz_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_size" ] pub fn __gmpz_size ( arg1 : mpz_srcptr ) -> usize ; } extern "C" { # [ link_name = "\u{1}___gmpz_sizeinbase" ] pub fn __gmpz_sizeinbase ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_int ) -> usize ; } extern "C" { # [ link_name = "\u{1}___gmpz_sqrt" ] pub fn __gmpz_sqrt ( arg1 : mpz_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_sqrtrem" ] pub fn __gmpz_sqrtrem ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_sub" ] pub fn __gmpz_sub ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_sub_ui" ] pub fn __gmpz_sub_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_ui_sub" ] pub fn __gmpz_ui_sub ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_submul" ] pub fn __gmpz_submul ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_submul_ui" ] pub fn __gmpz_submul_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_swap" ] pub fn __gmpz_swap ( arg1 : mpz_ptr , arg2 : mpz_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_ui" ] pub fn __gmpz_tdiv_ui ( arg1 : mpz_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_q" ] pub fn __gmpz_tdiv_q ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_q_2exp" ] pub fn __gmpz_tdiv_q_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_q_ui" ] pub fn __gmpz_tdiv_q_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_qr" ] pub fn __gmpz_tdiv_qr ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_qr_ui" ] pub fn __gmpz_tdiv_qr_ui ( arg1 : mpz_ptr , arg2 : mpz_ptr , arg3 : mpz_srcptr , arg4 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_r" ] pub fn __gmpz_tdiv_r ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_r_2exp" ] pub fn __gmpz_tdiv_r_2exp ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_tdiv_r_ui" ] pub fn __gmpz_tdiv_r_ui ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpz_tstbit" ] pub fn __gmpz_tstbit ( arg1 : mpz_srcptr , arg2 : mp_bitcnt_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpz_ui_pow_ui" ] pub fn __gmpz_ui_pow_ui ( arg1 : mpz_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_urandomb" ] pub fn __gmpz_urandomb ( arg1 : mpz_ptr , arg2 : * mut __gmp_randstate_struct , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_urandomm" ] pub fn __gmpz_urandomm ( arg1 : mpz_ptr , arg2 : * mut __gmp_randstate_struct , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_xor" ] pub fn __gmpz_xor ( arg1 : mpz_ptr , arg2 : mpz_srcptr , arg3 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_limbs_read" ] pub fn __gmpz_limbs_read ( arg1 : mpz_srcptr ) -> mp_srcptr ; } extern "C" { # [ link_name = "\u{1}___gmpz_limbs_write" ] pub fn __gmpz_limbs_write ( arg1 : mpz_ptr , arg2 : mp_size_t ) -> mp_ptr ; } extern "C" { # [ link_name = "\u{1}___gmpz_limbs_modify" ] pub fn __gmpz_limbs_modify ( arg1 : mpz_ptr , arg2 : mp_size_t ) -> mp_ptr ; } extern "C" { # [ link_name = "\u{1}___gmpz_limbs_finish" ] pub fn __gmpz_limbs_finish ( arg1 : mpz_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpz_roinit_n" ] pub fn __gmpz_roinit_n ( arg1 : mpz_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) -> mpz_srcptr ; } extern "C" { # [ link_name = "\u{1}___gmpq_abs" ] pub fn __gmpq_abs ( arg1 : mpq_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_add" ] pub fn __gmpq_add ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_canonicalize" ] pub fn __gmpq_canonicalize ( arg1 : mpq_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_clear" ] pub fn __gmpq_clear ( arg1 : mpq_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_clears" ] pub fn __gmpq_clears ( arg1 : mpq_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_cmp" ] pub fn __gmpq_cmp ( arg1 : mpq_srcptr , arg2 : mpq_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_cmp_si" ] pub fn __gmpq_cmp_si ( arg1 : mpq_srcptr , arg2 : :: std :: os :: raw :: c_long , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_cmp_ui" ] pub fn __gmpq_cmp_ui ( arg1 : mpq_srcptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_cmp_z" ] pub fn __gmpq_cmp_z ( arg1 : mpq_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_div" ] pub fn __gmpq_div ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_div_2exp" ] pub fn __gmpq_div_2exp ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_equal" ] pub fn __gmpq_equal ( arg1 : mpq_srcptr , arg2 : mpq_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_get_num" ] pub fn __gmpq_get_num ( arg1 : mpz_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_get_den" ] pub fn __gmpq_get_den ( arg1 : mpz_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_get_d" ] pub fn __gmpq_get_d ( arg1 : mpq_srcptr ) -> f64 ; } extern "C" { # [ link_name = "\u{1}___gmpq_get_str" ] pub fn __gmpq_get_str ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : :: std :: os :: raw :: c_int , arg3 : mpq_srcptr ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}___gmpq_init" ] pub fn __gmpq_init ( arg1 : mpq_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_inits" ] pub fn __gmpq_inits ( arg1 : mpq_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_inv" ] pub fn __gmpq_inv ( arg1 : mpq_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_mul" ] pub fn __gmpq_mul ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_mul_2exp" ] pub fn __gmpq_mul_2exp ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_neg" ] pub fn __gmpq_neg ( arg1 : mpq_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set" ] pub fn __gmpq_set ( arg1 : mpq_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_d" ] pub fn __gmpq_set_d ( arg1 : mpq_ptr , arg2 : f64 ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_den" ] pub fn __gmpq_set_den ( arg1 : mpq_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_f" ] pub fn __gmpq_set_f ( arg1 : mpq_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_num" ] pub fn __gmpq_set_num ( arg1 : mpq_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_si" ] pub fn __gmpq_set_si ( arg1 : mpq_ptr , arg2 : :: std :: os :: raw :: c_long , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_str" ] pub fn __gmpq_set_str ( arg1 : mpq_ptr , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_ui" ] pub fn __gmpq_set_ui ( arg1 : mpq_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_set_z" ] pub fn __gmpq_set_z ( arg1 : mpq_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_sub" ] pub fn __gmpq_sub ( arg1 : mpq_ptr , arg2 : mpq_srcptr , arg3 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpq_swap" ] pub fn __gmpq_swap ( arg1 : mpq_ptr , arg2 : mpq_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_abs" ] pub fn __gmpf_abs ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_add" ] pub fn __gmpf_add ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_add_ui" ] pub fn __gmpf_add_ui ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_ceil" ] pub fn __gmpf_ceil ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_clear" ] pub fn __gmpf_clear ( arg1 : mpf_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_clears" ] pub fn __gmpf_clears ( arg1 : mpf_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_cmp" ] pub fn __gmpf_cmp ( arg1 : mpf_srcptr , arg2 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_cmp_z" ] pub fn __gmpf_cmp_z ( arg1 : mpf_srcptr , arg2 : mpz_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_cmp_d" ] pub fn __gmpf_cmp_d ( arg1 : mpf_srcptr , arg2 : f64 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_cmp_si" ] pub fn __gmpf_cmp_si ( arg1 : mpf_srcptr , arg2 : :: std :: os :: raw :: c_long ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_cmp_ui" ] pub fn __gmpf_cmp_ui ( arg1 : mpf_srcptr , arg2 : :: std :: os :: raw :: c_ulong ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_div" ] pub fn __gmpf_div ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_div_2exp" ] pub fn __gmpf_div_2exp ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_div_ui" ] pub fn __gmpf_div_ui ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_dump" ] pub fn __gmpf_dump ( arg1 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_eq" ] pub fn __gmpf_eq ( arg1 : mpf_srcptr , arg2 : mpf_srcptr , arg3 : mp_bitcnt_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_sint_p" ] pub fn __gmpf_fits_sint_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_slong_p" ] pub fn __gmpf_fits_slong_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_sshort_p" ] pub fn __gmpf_fits_sshort_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_uint_p" ] pub fn __gmpf_fits_uint_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_ulong_p" ] pub fn __gmpf_fits_ulong_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_fits_ushort_p" ] pub fn __gmpf_fits_ushort_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_floor" ] pub fn __gmpf_floor ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_d" ] pub fn __gmpf_get_d ( arg1 : mpf_srcptr ) -> f64 ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_d_2exp" ] pub fn __gmpf_get_d_2exp ( arg1 : * mut :: std :: os :: raw :: c_long , arg2 : mpf_srcptr ) -> f64 ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_default_prec" ] pub fn __gmpf_get_default_prec ( ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_prec" ] pub fn __gmpf_get_prec ( arg1 : mpf_srcptr ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_si" ] pub fn __gmpf_get_si ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_str" ] pub fn __gmpf_get_str ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * mut mp_exp_t , arg3 : :: std :: os :: raw :: c_int , arg4 : usize , arg5 : mpf_srcptr ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}___gmpf_get_ui" ] pub fn __gmpf_get_ui ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}___gmpf_init" ] pub fn __gmpf_init ( arg1 : mpf_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_init2" ] pub fn __gmpf_init2 ( arg1 : mpf_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_inits" ] pub fn __gmpf_inits ( arg1 : mpf_ptr , ... ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_init_set" ] pub fn __gmpf_init_set ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_init_set_d" ] pub fn __gmpf_init_set_d ( arg1 : mpf_ptr , arg2 : f64 ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_init_set_si" ] pub fn __gmpf_init_set_si ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_init_set_str" ] pub fn __gmpf_init_set_str ( arg1 : mpf_ptr , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_init_set_ui" ] pub fn __gmpf_init_set_ui ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_integer_p" ] pub fn __gmpf_integer_p ( arg1 : mpf_srcptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_mul" ] pub fn __gmpf_mul ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_mul_2exp" ] pub fn __gmpf_mul_2exp ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_mul_ui" ] pub fn __gmpf_mul_ui ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_neg" ] pub fn __gmpf_neg ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_pow_ui" ] pub fn __gmpf_pow_ui ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_random2" ] pub fn __gmpf_random2 ( arg1 : mpf_ptr , arg2 : mp_size_t , arg3 : mp_exp_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_reldiff" ] pub fn __gmpf_reldiff ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set" ] pub fn __gmpf_set ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_d" ] pub fn __gmpf_set_d ( arg1 : mpf_ptr , arg2 : f64 ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_default_prec" ] pub fn __gmpf_set_default_prec ( arg1 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_prec" ] pub fn __gmpf_set_prec ( arg1 : mpf_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_prec_raw" ] pub fn __gmpf_set_prec_raw ( arg1 : mpf_ptr , arg2 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_q" ] pub fn __gmpf_set_q ( arg1 : mpf_ptr , arg2 : mpq_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_si" ] pub fn __gmpf_set_si ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_str" ] pub fn __gmpf_set_str ( arg1 : mpf_ptr , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_ui" ] pub fn __gmpf_set_ui ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_set_z" ] pub fn __gmpf_set_z ( arg1 : mpf_ptr , arg2 : mpz_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_size" ] pub fn __gmpf_size ( arg1 : mpf_srcptr ) -> usize ; } extern "C" { # [ link_name = "\u{1}___gmpf_sqrt" ] pub fn __gmpf_sqrt ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_sqrt_ui" ] pub fn __gmpf_sqrt_ui ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_sub" ] pub fn __gmpf_sub ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_sub_ui" ] pub fn __gmpf_sub_ui ( arg1 : mpf_ptr , arg2 : mpf_srcptr , arg3 : :: std :: os :: raw :: c_ulong ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_swap" ] pub fn __gmpf_swap ( arg1 : mpf_ptr , arg2 : mpf_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_trunc" ] pub fn __gmpf_trunc ( arg1 : mpf_ptr , arg2 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_ui_div" ] pub fn __gmpf_ui_div ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_ui_sub" ] pub fn __gmpf_ui_sub ( arg1 : mpf_ptr , arg2 : :: std :: os :: raw :: c_ulong , arg3 : mpf_srcptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpf_urandomb" ] pub fn __gmpf_urandomb ( arg1 : * mut __mpf_struct , arg2 : * mut __gmp_randstate_struct , arg3 : mp_bitcnt_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_add" ] pub fn __gmpn_add ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_add_1" ] pub fn __gmpn_add_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_add_n" ] pub fn __gmpn_add_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_addmul_1" ] pub fn __gmpn_addmul_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_cmp" ] pub fn __gmpn_cmp ( arg1 : mp_srcptr , arg2 : mp_srcptr , arg3 : mp_size_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpn_zero_p" ] pub fn __gmpn_zero_p ( arg1 : mp_srcptr , arg2 : mp_size_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpn_divexact_1" ] pub fn __gmpn_divexact_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_divexact_by3c" ] pub fn __gmpn_divexact_by3c ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_divrem" ] pub fn __gmpn_divrem ( arg1 : mp_ptr , arg2 : mp_size_t , arg3 : mp_ptr , arg4 : mp_size_t , arg5 : mp_srcptr , arg6 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_divrem_1" ] pub fn __gmpn_divrem_1 ( arg1 : mp_ptr , arg2 : mp_size_t , arg3 : mp_srcptr , arg4 : mp_size_t , arg5 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_divrem_2" ] pub fn __gmpn_divrem_2 ( arg1 : mp_ptr , arg2 : mp_size_t , arg3 : mp_ptr , arg4 : mp_size_t , arg5 : mp_srcptr ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_div_qr_1" ] pub fn __gmpn_div_qr_1 ( arg1 : mp_ptr , arg2 : * mut mp_limb_t , arg3 : mp_srcptr , arg4 : mp_size_t , arg5 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_div_qr_2" ] pub fn __gmpn_div_qr_2 ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_srcptr , arg4 : mp_size_t , arg5 : mp_srcptr ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_gcd" ] pub fn __gmpn_gcd ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_size_t , arg4 : mp_ptr , arg5 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_gcd_1" ] pub fn __gmpn_gcd_1 ( arg1 : mp_srcptr , arg2 : mp_size_t , arg3 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_gcdext_1" ] pub fn __gmpn_gcdext_1 ( arg1 : * mut mp_limb_signed_t , arg2 : * mut mp_limb_signed_t , arg3 : mp_limb_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_gcdext" ] pub fn __gmpn_gcdext ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : * mut mp_size_t , arg4 : mp_ptr , arg5 : mp_size_t , arg6 : mp_ptr , arg7 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_get_str" ] pub fn __gmpn_get_str ( arg1 : * mut :: std :: os :: raw :: c_uchar , arg2 : :: std :: os :: raw :: c_int , arg3 : mp_ptr , arg4 : mp_size_t ) -> usize ; } extern "C" { # [ link_name = "\u{1}___gmpn_hamdist" ] pub fn __gmpn_hamdist ( arg1 : mp_srcptr , arg2 : mp_srcptr , arg3 : mp_size_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_lshift" ] pub fn __gmpn_lshift ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : :: std :: os :: raw :: c_uint ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_mod_1" ] pub fn __gmpn_mod_1 ( arg1 : mp_srcptr , arg2 : mp_size_t , arg3 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_mul" ] pub fn __gmpn_mul ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_mul_1" ] pub fn __gmpn_mul_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_mul_n" ] pub fn __gmpn_mul_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sqr" ] pub fn __gmpn_sqr ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_neg" ] pub fn __gmpn_neg ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_com" ] pub fn __gmpn_com ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_perfect_square_p" ] pub fn __gmpn_perfect_square_p ( arg1 : mp_srcptr , arg2 : mp_size_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpn_perfect_power_p" ] pub fn __gmpn_perfect_power_p ( arg1 : mp_srcptr , arg2 : mp_size_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpn_popcount" ] pub fn __gmpn_popcount ( arg1 : mp_srcptr , arg2 : mp_size_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_pow_1" ] pub fn __gmpn_pow_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t , arg5 : mp_ptr ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_preinv_mod_1" ] pub fn __gmpn_preinv_mod_1 ( arg1 : mp_srcptr , arg2 : mp_size_t , arg3 : mp_limb_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_random" ] pub fn __gmpn_random ( arg1 : mp_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_random2" ] pub fn __gmpn_random2 ( arg1 : mp_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_rshift" ] pub fn __gmpn_rshift ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : :: std :: os :: raw :: c_uint ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_scan0" ] pub fn __gmpn_scan0 ( arg1 : mp_srcptr , arg2 : mp_bitcnt_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_scan1" ] pub fn __gmpn_scan1 ( arg1 : mp_srcptr , arg2 : mp_bitcnt_t ) -> mp_bitcnt_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_set_str" ] pub fn __gmpn_set_str ( arg1 : mp_ptr , arg2 : * const :: std :: os :: raw :: c_uchar , arg3 : usize , arg4 : :: std :: os :: raw :: c_int ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sizeinbase" ] pub fn __gmpn_sizeinbase ( arg1 : mp_srcptr , arg2 : mp_size_t , arg3 : :: std :: os :: raw :: c_int ) -> usize ; } extern "C" { # [ link_name = "\u{1}___gmpn_sqrtrem" ] pub fn __gmpn_sqrtrem ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_srcptr , arg4 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sub" ] pub fn __gmpn_sub ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sub_1" ] pub fn __gmpn_sub_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sub_n" ] pub fn __gmpn_sub_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_submul_1" ] pub fn __gmpn_submul_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_tdiv_qr" ] pub fn __gmpn_tdiv_qr ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t , arg6 : mp_srcptr , arg7 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_and_n" ] pub fn __gmpn_and_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_andn_n" ] pub fn __gmpn_andn_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_nand_n" ] pub fn __gmpn_nand_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_ior_n" ] pub fn __gmpn_ior_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_iorn_n" ] pub fn __gmpn_iorn_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_nior_n" ] pub fn __gmpn_nior_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_xor_n" ] pub fn __gmpn_xor_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_xnor_n" ] pub fn __gmpn_xnor_n ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_srcptr , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_copyi" ] pub fn __gmpn_copyi ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_copyd" ] pub fn __gmpn_copyd ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_zero" ] pub fn __gmpn_zero ( arg1 : mp_ptr , arg2 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_cnd_add_n" ] pub fn __gmpn_cnd_add_n ( arg1 : mp_limb_t , arg2 : mp_ptr , arg3 : mp_srcptr , arg4 : mp_srcptr , arg5 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_cnd_sub_n" ] pub fn __gmpn_cnd_sub_n ( arg1 : mp_limb_t , arg2 : mp_ptr , arg3 : mp_srcptr , arg4 : mp_srcptr , arg5 : mp_size_t ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_add_1" ] pub fn __gmpn_sec_add_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t , arg5 : mp_ptr ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_add_1_itch" ] pub fn __gmpn_sec_add_1_itch ( arg1 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_sub_1" ] pub fn __gmpn_sec_sub_1 ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_limb_t , arg5 : mp_ptr ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_sub_1_itch" ] pub fn __gmpn_sec_sub_1_itch ( arg1 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_cnd_swap" ] pub fn __gmpn_cnd_swap ( arg1 : mp_limb_t , arg2 : * mut mp_limb_t , arg3 : * mut mp_limb_t , arg4 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_mul" ] pub fn __gmpn_sec_mul ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t , arg6 : mp_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_mul_itch" ] pub fn __gmpn_sec_mul_itch ( arg1 : mp_size_t , arg2 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_sqr" ] pub fn __gmpn_sec_sqr ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_sqr_itch" ] pub fn __gmpn_sec_sqr_itch ( arg1 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_powm" ] pub fn __gmpn_sec_powm ( arg1 : mp_ptr , arg2 : mp_srcptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_bitcnt_t , arg6 : mp_srcptr , arg7 : mp_size_t , arg8 : mp_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_powm_itch" ] pub fn __gmpn_sec_powm_itch ( arg1 : mp_size_t , arg2 : mp_bitcnt_t , arg3 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_tabselect" ] pub fn __gmpn_sec_tabselect ( arg1 : * mut mp_limb_t , arg2 : * const mp_limb_t , arg3 : mp_size_t , arg4 : mp_size_t , arg5 : mp_size_t ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_div_qr" ] pub fn __gmpn_sec_div_qr ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_size_t , arg4 : mp_srcptr , arg5 : mp_size_t , arg6 : mp_ptr ) -> mp_limb_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_div_qr_itch" ] pub fn __gmpn_sec_div_qr_itch ( arg1 : mp_size_t , arg2 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_div_r" ] pub fn __gmpn_sec_div_r ( arg1 : mp_ptr , arg2 : mp_size_t , arg3 : mp_srcptr , arg4 : mp_size_t , arg5 : mp_ptr ) ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_div_r_itch" ] pub fn __gmpn_sec_div_r_itch ( arg1 : mp_size_t , arg2 : mp_size_t ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_invert" ] pub fn __gmpn_sec_invert ( arg1 : mp_ptr , arg2 : mp_ptr , arg3 : mp_srcptr , arg4 : mp_size_t , arg5 : mp_bitcnt_t , arg6 : mp_ptr ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}___gmpn_sec_invert_itch" ] pub fn __gmpn_sec_invert_itch ( arg1 : mp_size_t ) -> mp_size_t ; } pub const GMP_ERROR_NONE : _bindgen_ty_2 = 0 ; pub const GMP_ERROR_UNSUPPORTED_ARGUMENT : _bindgen_ty_2 = 1 ; pub const GMP_ERROR_DIVISION_BY_ZERO : _bindgen_ty_2 = 2 ; pub const GMP_ERROR_SQRT_OF_NEGATIVE : _bindgen_ty_2 = 4 ; pub const GMP_ERROR_INVALID_ARGUMENT : _bindgen_ty_2 = 8 ; pub type _bindgen_ty_2 = u32 ; extern "C" { # [ link_name = "\u{1}_nettle_mpz_sizeinbase_256_s" ] pub fn nettle_mpz_sizeinbase_256_s ( x : * mut __mpz_struct ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_sizeinbase_256_u" ] pub fn nettle_mpz_sizeinbase_256_u ( x : * mut __mpz_struct ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_get_str_256" ] pub fn nettle_mpz_get_str_256 ( length : usize , s : * mut u8 , x : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_set_str_256_s" ] pub fn nettle_mpz_set_str_256_s ( x : * mut __mpz_struct , length : usize , s : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_init_set_str_256_s" ] pub fn nettle_mpz_init_set_str_256_s ( x : * mut __mpz_struct , length : usize , s : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_set_str_256_u" ] pub fn nettle_mpz_set_str_256_u ( x : * mut __mpz_struct , length : usize , s : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_init_set_str_256_u" ] pub fn nettle_mpz_init_set_str_256_u ( x : * mut __mpz_struct , length : usize , s : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_random_size" ] pub fn nettle_mpz_random_size ( x : * mut __mpz_struct , ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , bits : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_random" ] pub fn nettle_mpz_random ( x : * mut __mpz_struct , ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , n : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_random_prime" ] pub fn nettle_random_prime ( p : * mut __mpz_struct , bits : :: std :: os :: raw :: c_uint , top_bits_set : :: std :: os :: raw :: c_int , ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , progress_ctx : * mut :: std :: os :: raw :: c_void , progress : nettle_progress_func ) ; } extern "C" { # [ link_name = "\u{1}__nettle_generate_pocklington_prime" ] pub fn _nettle_generate_pocklington_prime ( p : * mut __mpz_struct , r : * mut __mpz_struct , bits : :: std :: os :: raw :: c_uint , top_bits_set : :: std :: os :: raw :: c_int , ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , p0 : * mut __mpz_struct , q : * mut __mpz_struct , p0q : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_mpz_set_sexp" ] pub fn nettle_mpz_set_sexp ( x : * mut __mpz_struct , limit : :: std :: os :: raw :: c_uint , i : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_asn1_der_get_bignum" ] pub fn nettle_asn1_der_get_bignum ( iterator : * mut asn1_der_iterator , x : * mut __mpz_struct , max_bits : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct blowfish_ctx { pub s : [ [ u32 ; 256usize ] ; 4usize ] , pub p : [ u32 ; 18usize ] , } # [ test ] fn bindgen_test_layout_blowfish_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < blowfish_ctx > ( ) , 4168usize , concat ! ( "Size of: " , stringify ! ( blowfish_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < blowfish_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( blowfish_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < blowfish_ctx > ( ) ) ) . s as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( blowfish_ctx ) , "::" , stringify ! ( s ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < blowfish_ctx > ( ) ) ) . p as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( blowfish_ctx ) , "::" , stringify ! ( p ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_blowfish_set_key" ] pub fn nettle_blowfish_set_key ( ctx : * mut blowfish_ctx , length : usize , key : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_blowfish128_set_key" ] pub fn nettle_blowfish128_set_key ( ctx : * mut blowfish_ctx , key : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_blowfish_encrypt" ] pub fn nettle_blowfish_encrypt ( ctx : * const blowfish_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_blowfish_decrypt" ] pub fn nettle_blowfish_decrypt ( ctx : * const blowfish_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_realloc" ] pub fn nettle_realloc ( ctx : * mut :: std :: os :: raw :: c_void , p : * mut :: std :: os :: raw :: c_void , length : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_nettle_xrealloc" ] pub fn nettle_xrealloc ( ctx : * mut :: std :: os :: raw :: c_void , p : * mut :: std :: os :: raw :: c_void , length : usize ) -> * mut :: std :: os :: raw :: c_void ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct nettle_buffer { pub contents : * mut u8 , pub alloc : usize , pub realloc_ctx : * mut :: std :: os :: raw :: c_void , pub realloc : nettle_realloc_func , pub size : usize , } # [ test ] fn bindgen_test_layout_nettle_buffer ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nettle_buffer > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( nettle_buffer ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nettle_buffer > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nettle_buffer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_buffer > ( ) ) ) . contents as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( nettle_buffer ) , "::" , stringify ! ( contents ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_buffer > ( ) ) ) . alloc as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( nettle_buffer ) , "::" , stringify ! ( alloc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_buffer > ( ) ) ) . realloc_ctx as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( nettle_buffer ) , "::" , stringify ! ( realloc_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_buffer > ( ) ) ) . realloc as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( nettle_buffer ) , "::" , stringify ! ( realloc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < nettle_buffer > ( ) ) ) . size as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( nettle_buffer ) , "::" , stringify ! ( size ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_init" ] pub fn nettle_buffer_init ( buffer : * mut nettle_buffer ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_init_realloc" ] pub fn nettle_buffer_init_realloc ( buffer : * mut nettle_buffer , realloc_ctx : * mut :: std :: os :: raw :: c_void , realloc : nettle_realloc_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_init_size" ] pub fn nettle_buffer_init_size ( buffer : * mut nettle_buffer , length : usize , space : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_clear" ] pub fn nettle_buffer_clear ( buffer : * mut nettle_buffer ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_reset" ] pub fn nettle_buffer_reset ( buffer : * mut nettle_buffer ) ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_grow" ] pub fn nettle_buffer_grow ( buffer : * mut nettle_buffer , length : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_write" ] pub fn nettle_buffer_write ( buffer : * mut nettle_buffer , length : usize , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_space" ] pub fn nettle_buffer_space ( buffer : * mut nettle_buffer , length : usize ) -> * mut u8 ; } extern "C" { # [ link_name = "\u{1}_nettle_buffer_copy" ] pub fn nettle_buffer_copy ( dst : * mut nettle_buffer , src : * const nettle_buffer ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct camellia128_ctx { pub keys : [ u64 ; 24usize ] , } # [ test ] fn bindgen_test_layout_camellia128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < camellia128_ctx > ( ) , 192usize , concat ! ( "Size of: " , stringify ! ( camellia128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < camellia128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( camellia128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < camellia128_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( camellia128_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia128_set_encrypt_key" ] pub fn nettle_camellia128_set_encrypt_key ( ctx : * mut camellia128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia_set_decrypt_key" ] pub fn nettle_camellia_set_decrypt_key ( ctx : * mut camellia128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia128_invert_key" ] pub fn nettle_camellia128_invert_key ( dst : * mut camellia128_ctx , src : * const camellia128_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia128_crypt" ] pub fn nettle_camellia128_crypt ( ctx : * const camellia128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct camellia256_ctx { pub keys : [ u64 ; 32usize ] , } # [ test ] fn bindgen_test_layout_camellia256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < camellia256_ctx > ( ) , 256usize , concat ! ( "Size of: " , stringify ! ( camellia256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < camellia256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( camellia256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < camellia256_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( camellia256_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia256_set_encrypt_key" ] pub fn nettle_camellia256_set_encrypt_key ( ctx : * mut camellia256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia256_set_decrypt_key" ] pub fn nettle_camellia256_set_decrypt_key ( ctx : * mut camellia256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia256_invert_key" ] pub fn nettle_camellia256_invert_key ( dst : * mut camellia256_ctx , src : * const camellia256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia256_crypt" ] pub fn nettle_camellia256_crypt ( ctx : * const camellia256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia192_set_encrypt_key" ] pub fn nettle_camellia192_set_encrypt_key ( ctx : * mut camellia256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_camellia192_set_decrypt_key" ] pub fn nettle_camellia192_set_decrypt_key ( ctx : * mut camellia256_ctx , key : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cast128_ctx { pub rounds : :: std :: os :: raw :: c_uint , pub Kr : [ :: std :: os :: raw :: c_uchar ; 16usize ] , pub Km : [ u32 ; 16usize ] , } # [ test ] fn bindgen_test_layout_cast128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < cast128_ctx > ( ) , 84usize , concat ! ( "Size of: " , stringify ! ( cast128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < cast128_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( cast128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cast128_ctx > ( ) ) ) . rounds as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( cast128_ctx ) , "::" , stringify ! ( rounds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cast128_ctx > ( ) ) ) . Kr as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( cast128_ctx ) , "::" , stringify ! ( Kr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cast128_ctx > ( ) ) ) . Km as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( cast128_ctx ) , "::" , stringify ! ( Km ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cast5_set_key" ] pub fn nettle_cast5_set_key ( ctx : * mut cast128_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cast128_set_key" ] pub fn nettle_cast128_set_key ( ctx : * mut cast128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cast128_encrypt" ] pub fn nettle_cast128_encrypt ( ctx : * const cast128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cast128_decrypt" ] pub fn nettle_cast128_decrypt ( ctx : * const cast128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cbc_encrypt" ] pub fn nettle_cbc_encrypt ( ctx : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , block_size : usize , iv : * mut u8 , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cbc_decrypt" ] pub fn nettle_cbc_decrypt ( ctx : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , block_size : usize , iv : * mut u8 , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct ccm_ctx { pub ctr : nettle_block16 , pub tag : nettle_block16 , pub blength : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_ccm_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ccm_ctx > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( ccm_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ccm_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ccm_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_ctx > ( ) ) ) . ctr as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ccm_ctx ) , "::" , stringify ! ( ctr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_ctx > ( ) ) ) . tag as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( ccm_ctx ) , "::" , stringify ! ( tag ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_ctx > ( ) ) ) . blength as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( ccm_ctx ) , "::" , stringify ! ( blength ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_set_nonce" ] pub fn nettle_ccm_set_nonce ( ctx : * mut ccm_ctx , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , noncelen : usize , nonce : * const u8 , authlen : usize , msglen : usize , taglen : usize ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_update" ] pub fn nettle_ccm_update ( ctx : * mut ccm_ctx , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_encrypt" ] pub fn nettle_ccm_encrypt ( ctx : * mut ccm_ctx , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_decrypt" ] pub fn nettle_ccm_decrypt ( ctx : * mut ccm_ctx , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_digest" ] pub fn nettle_ccm_digest ( ctx : * mut ccm_ctx , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_encrypt_message" ] pub fn nettle_ccm_encrypt_message ( cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , clength : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_decrypt_message" ] pub fn nettle_ccm_decrypt_message ( cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , mlength : usize , dst : * mut u8 , src : * const u8 ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct ccm_aes128_ctx { pub ccm : ccm_ctx , pub cipher : aes128_ctx , } # [ test ] fn bindgen_test_layout_ccm_aes128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ccm_aes128_ctx > ( ) , 216usize , concat ! ( "Size of: " , stringify ! ( ccm_aes128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ccm_aes128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ccm_aes128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes128_ctx > ( ) ) ) . ccm as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes128_ctx ) , "::" , stringify ! ( ccm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes128_ctx > ( ) ) ) . cipher as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes128_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_set_key" ] pub fn nettle_ccm_aes128_set_key ( ctx : * mut ccm_aes128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_set_nonce" ] pub fn nettle_ccm_aes128_set_nonce ( ctx : * mut ccm_aes128_ctx , length : usize , nonce : * const u8 , authlen : usize , msglen : usize , taglen : usize ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_update" ] pub fn nettle_ccm_aes128_update ( ctx : * mut ccm_aes128_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_encrypt" ] pub fn nettle_ccm_aes128_encrypt ( ctx : * mut ccm_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_decrypt" ] pub fn nettle_ccm_aes128_decrypt ( ctx : * mut ccm_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_digest" ] pub fn nettle_ccm_aes128_digest ( ctx : * mut ccm_aes128_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_encrypt_message" ] pub fn nettle_ccm_aes128_encrypt_message ( ctx : * mut ccm_aes128_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , clength : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes128_decrypt_message" ] pub fn nettle_ccm_aes128_decrypt_message ( ctx : * mut ccm_aes128_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , mlength : usize , dst : * mut u8 , src : * const u8 ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct ccm_aes192_ctx { pub ccm : ccm_ctx , pub cipher : aes192_ctx , } # [ test ] fn bindgen_test_layout_ccm_aes192_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ccm_aes192_ctx > ( ) , 248usize , concat ! ( "Size of: " , stringify ! ( ccm_aes192_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ccm_aes192_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ccm_aes192_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes192_ctx > ( ) ) ) . ccm as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes192_ctx ) , "::" , stringify ! ( ccm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes192_ctx > ( ) ) ) . cipher as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes192_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_set_key" ] pub fn nettle_ccm_aes192_set_key ( ctx : * mut ccm_aes192_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_set_nonce" ] pub fn nettle_ccm_aes192_set_nonce ( ctx : * mut ccm_aes192_ctx , length : usize , nonce : * const u8 , authlen : usize , msglen : usize , taglen : usize ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_update" ] pub fn nettle_ccm_aes192_update ( ctx : * mut ccm_aes192_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_encrypt" ] pub fn nettle_ccm_aes192_encrypt ( ctx : * mut ccm_aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_decrypt" ] pub fn nettle_ccm_aes192_decrypt ( ctx : * mut ccm_aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_digest" ] pub fn nettle_ccm_aes192_digest ( ctx : * mut ccm_aes192_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_encrypt_message" ] pub fn nettle_ccm_aes192_encrypt_message ( ctx : * mut ccm_aes192_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , clength : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes192_decrypt_message" ] pub fn nettle_ccm_aes192_decrypt_message ( ctx : * mut ccm_aes192_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , mlength : usize , dst : * mut u8 , src : * const u8 ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct ccm_aes256_ctx { pub ccm : ccm_ctx , pub cipher : aes256_ctx , } # [ test ] fn bindgen_test_layout_ccm_aes256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ccm_aes256_ctx > ( ) , 280usize , concat ! ( "Size of: " , stringify ! ( ccm_aes256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ccm_aes256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ccm_aes256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes256_ctx > ( ) ) ) . ccm as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes256_ctx ) , "::" , stringify ! ( ccm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ccm_aes256_ctx > ( ) ) ) . cipher as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( ccm_aes256_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_set_key" ] pub fn nettle_ccm_aes256_set_key ( ctx : * mut ccm_aes256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_set_nonce" ] pub fn nettle_ccm_aes256_set_nonce ( ctx : * mut ccm_aes256_ctx , length : usize , nonce : * const u8 , authlen : usize , msglen : usize , taglen : usize ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_update" ] pub fn nettle_ccm_aes256_update ( ctx : * mut ccm_aes256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_encrypt" ] pub fn nettle_ccm_aes256_encrypt ( ctx : * mut ccm_aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_decrypt" ] pub fn nettle_ccm_aes256_decrypt ( ctx : * mut ccm_aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_digest" ] pub fn nettle_ccm_aes256_digest ( ctx : * mut ccm_aes256_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_encrypt_message" ] pub fn nettle_ccm_aes256_encrypt_message ( ctx : * mut ccm_aes256_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , clength : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ccm_aes256_decrypt_message" ] pub fn nettle_ccm_aes256_decrypt_message ( ctx : * mut ccm_aes256_ctx , nlength : usize , nonce : * const u8 , alength : usize , adata : * const u8 , tlength : usize , mlength : usize , dst : * mut u8 , src : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_cfb_encrypt" ] pub fn nettle_cfb_encrypt ( ctx : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , block_size : usize , iv : * mut u8 , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_cfb_decrypt" ] pub fn nettle_cfb_decrypt ( ctx : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , block_size : usize , iv : * mut u8 , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct chacha_ctx { pub state : [ u32 ; 16usize ] , } # [ test ] fn bindgen_test_layout_chacha_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < chacha_ctx > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( chacha_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < chacha_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( chacha_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( chacha_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_set_key" ] pub fn nettle_chacha_set_key ( ctx : * mut chacha_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_set_nonce" ] pub fn nettle_chacha_set_nonce ( ctx : * mut chacha_ctx , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_set_nonce96" ] pub fn nettle_chacha_set_nonce96 ( ctx : * mut chacha_ctx , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_crypt" ] pub fn nettle_chacha_crypt ( ctx : * mut chacha_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_chacha_core" ] pub fn _nettle_chacha_core ( dst : * mut u32 , src : * const u32 , rounds : :: std :: os :: raw :: c_uint ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct poly1305_ctx { pub r : poly1305_ctx__bindgen_ty_1 , pub s32 : [ u32 ; 3usize ] , pub hh : u32 , pub h : poly1305_ctx__bindgen_ty_2 , } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union poly1305_ctx__bindgen_ty_1 { pub r32 : [ u32 ; 6usize ] , pub r64 : [ u64 ; 3usize ] , _bindgen_union_align : [ u64 ; 3usize ] , } # [ test ] fn bindgen_test_layout_poly1305_ctx__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < poly1305_ctx__bindgen_ty_1 > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( poly1305_ctx__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < poly1305_ctx__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( poly1305_ctx__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx__bindgen_ty_1 > ( ) ) ) . r32 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx__bindgen_ty_1 ) , "::" , stringify ! ( r32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx__bindgen_ty_1 > ( ) ) ) . r64 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx__bindgen_ty_1 ) , "::" , stringify ! ( r64 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union poly1305_ctx__bindgen_ty_2 { pub h32 : [ u32 ; 4usize ] , pub h64 : [ u64 ; 2usize ] , _bindgen_union_align : [ u64 ; 2usize ] , } # [ test ] fn bindgen_test_layout_poly1305_ctx__bindgen_ty_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < poly1305_ctx__bindgen_ty_2 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( poly1305_ctx__bindgen_ty_2 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < poly1305_ctx__bindgen_ty_2 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( poly1305_ctx__bindgen_ty_2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx__bindgen_ty_2 > ( ) ) ) . h32 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx__bindgen_ty_2 ) , "::" , stringify ! ( h32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx__bindgen_ty_2 > ( ) ) ) . h64 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx__bindgen_ty_2 ) , "::" , stringify ! ( h64 ) ) ) ; } # [ test ] fn bindgen_test_layout_poly1305_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < poly1305_ctx > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( poly1305_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < poly1305_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( poly1305_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx > ( ) ) ) . r as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx ) , "::" , stringify ! ( r ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx > ( ) ) ) . s32 as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx ) , "::" , stringify ! ( s32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx > ( ) ) ) . hh as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx ) , "::" , stringify ! ( hh ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_ctx > ( ) ) ) . h as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_ctx ) , "::" , stringify ! ( h ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_set_key" ] pub fn nettle_poly1305_set_key ( ctx : * mut poly1305_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_digest" ] pub fn nettle_poly1305_digest ( ctx : * mut poly1305_ctx , s : * mut nettle_block16 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_poly1305_block" ] pub fn _nettle_poly1305_block ( ctx : * mut poly1305_ctx , m : * const u8 , high : :: std :: os :: raw :: c_uint ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct poly1305_aes_ctx { pub pctx : poly1305_ctx , pub block : [ u8 ; 16usize ] , pub index : :: std :: os :: raw :: c_uint , pub nonce : [ u8 ; 16usize ] , pub aes : aes128_ctx , } # [ test ] fn bindgen_test_layout_poly1305_aes_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < poly1305_aes_ctx > ( ) , 272usize , concat ! ( "Size of: " , stringify ! ( poly1305_aes_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < poly1305_aes_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( poly1305_aes_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_aes_ctx > ( ) ) ) . pctx as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_aes_ctx ) , "::" , stringify ! ( pctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_aes_ctx > ( ) ) ) . block as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_aes_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_aes_ctx > ( ) ) ) . index as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_aes_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_aes_ctx > ( ) ) ) . nonce as * const _ as usize } , 76usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_aes_ctx ) , "::" , stringify ! ( nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < poly1305_aes_ctx > ( ) ) ) . aes as * const _ as usize } , 92usize , concat ! ( "Offset of field: " , stringify ! ( poly1305_aes_ctx ) , "::" , stringify ! ( aes ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_aes_set_key" ] pub fn nettle_poly1305_aes_set_key ( ctx : * mut poly1305_aes_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_aes_set_nonce" ] pub fn nettle_poly1305_aes_set_nonce ( ctx : * mut poly1305_aes_ctx , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_aes_update" ] pub fn nettle_poly1305_aes_update ( ctx : * mut poly1305_aes_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_poly1305_aes_digest" ] pub fn nettle_poly1305_aes_digest ( ctx : * mut poly1305_aes_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct chacha_poly1305_ctx { pub chacha : chacha_ctx , pub poly1305 : poly1305_ctx , pub s : nettle_block16 , pub auth_size : u64 , pub data_size : u64 , pub block : [ u8 ; 16usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_chacha_poly1305_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < chacha_poly1305_ctx > ( ) , 176usize , concat ! ( "Size of: " , stringify ! ( chacha_poly1305_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < chacha_poly1305_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( chacha_poly1305_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . chacha as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( chacha ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . poly1305 as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( poly1305 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . s as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( s ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . auth_size as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( auth_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . data_size as * const _ as usize } , 144usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( data_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . block as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < chacha_poly1305_ctx > ( ) ) ) . index as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( chacha_poly1305_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_set_key" ] pub fn nettle_chacha_poly1305_set_key ( ctx : * mut chacha_poly1305_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_set_nonce" ] pub fn nettle_chacha_poly1305_set_nonce ( ctx : * mut chacha_poly1305_ctx , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_update" ] pub fn nettle_chacha_poly1305_update ( ctx : * mut chacha_poly1305_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_encrypt" ] pub fn nettle_chacha_poly1305_encrypt ( ctx : * mut chacha_poly1305_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_decrypt" ] pub fn nettle_chacha_poly1305_decrypt ( ctx : * mut chacha_poly1305_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_chacha_poly1305_digest" ] pub fn nettle_chacha_poly1305_digest ( ctx : * mut chacha_poly1305_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ctr_crypt" ] pub fn nettle_ctr_crypt ( ctx : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , block_size : usize , ctr : * mut u8 , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_curve25519_mul_g" ] pub fn nettle_curve25519_mul_g ( q : * mut u8 , n : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_curve25519_mul" ] pub fn nettle_curve25519_mul ( q : * mut u8 , n : * const u8 , p : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct des_ctx { pub key : [ u32 ; 32usize ] , } # [ test ] fn bindgen_test_layout_des_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < des_ctx > ( ) , 128usize , concat ! ( "Size of: " , stringify ! ( des_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < des_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( des_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < des_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( des_ctx ) , "::" , stringify ! ( key ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_des_set_key" ] pub fn nettle_des_set_key ( ctx : * mut des_ctx , key : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_des_encrypt" ] pub fn nettle_des_encrypt ( ctx : * const des_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_des_decrypt" ] pub fn nettle_des_decrypt ( ctx : * const des_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_des_check_parity" ] pub fn nettle_des_check_parity ( length : usize , key : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_des_fix_parity" ] pub fn nettle_des_fix_parity ( length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct des3_ctx { pub des : [ des_ctx ; 3usize ] , } # [ test ] fn bindgen_test_layout_des3_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < des3_ctx > ( ) , 384usize , concat ! ( "Size of: " , stringify ! ( des3_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < des3_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( des3_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < des3_ctx > ( ) ) ) . des as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( des3_ctx ) , "::" , stringify ! ( des ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_des3_set_key" ] pub fn nettle_des3_set_key ( ctx : * mut des3_ctx , key : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_des3_encrypt" ] pub fn nettle_des3_encrypt ( ctx : * const des3_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_des3_decrypt" ] pub fn nettle_des3_decrypt ( ctx : * const des3_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } pub const DES_DECRYPT : _bindgen_ty_3 = 0 ; pub const DES_ENCRYPT : _bindgen_ty_3 = 1 ; pub type _bindgen_ty_3 = u32 ; pub type DES_LONG = u32 ; pub type des_key_schedule = [ des_ctx ; 1usize ] ; pub type des_cblock = [ u8 ; 8usize ] ; extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_check_key" ] pub static mut nettle_openssl_des_check_key : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_ecb3_encrypt" ] pub fn nettle_openssl_des_ecb3_encrypt ( src : * mut des_cblock , dst : * mut des_cblock , k1 : * mut des_ctx , k2 : * mut des_ctx , k3 : * mut des_ctx , enc : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_cbc_cksum" ] pub fn nettle_openssl_des_cbc_cksum ( src : * const u8 , dst : * mut des_cblock , length : :: std :: os :: raw :: c_long , ctx : * mut des_ctx , iv : * mut des_cblock ) -> u32 ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_cbc_encrypt" ] pub fn nettle_openssl_des_cbc_encrypt ( src : * mut des_cblock , dst : * mut des_cblock , length : :: std :: os :: raw :: c_long , ctx : * mut des_ctx , iv : * mut des_cblock , enc : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_ncbc_encrypt" ] pub fn nettle_openssl_des_ncbc_encrypt ( src : * mut des_cblock , dst : * mut des_cblock , length : :: std :: os :: raw :: c_long , ctx : * mut des_ctx , iv : * mut des_cblock , enc : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_ecb_encrypt" ] pub fn nettle_openssl_des_ecb_encrypt ( src : * mut des_cblock , dst : * mut des_cblock , ctx : * mut des_ctx , enc : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_ede3_cbc_encrypt" ] pub fn nettle_openssl_des_ede3_cbc_encrypt ( src : * mut des_cblock , dst : * mut des_cblock , length : :: std :: os :: raw :: c_long , k1 : * mut des_ctx , k2 : * mut des_ctx , k3 : * mut des_ctx , iv : * mut des_cblock , enc : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_set_odd_parity" ] pub fn nettle_openssl_des_set_odd_parity ( key : * mut des_cblock ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_key_sched" ] pub fn nettle_openssl_des_key_sched ( key : * mut des_cblock , ctx : * mut des_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_des_is_weak_key" ] pub fn nettle_openssl_des_is_weak_key ( key : * mut des_cblock ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct dsa_params { pub p : mpz_t , pub q : mpz_t , pub g : mpz_t , } # [ test ] fn bindgen_test_layout_dsa_params ( ) { assert_eq ! ( :: std :: mem :: size_of :: < dsa_params > ( ) , 48usize , concat ! ( "Size of: " , stringify ! ( dsa_params ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < dsa_params > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( dsa_params ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_params > ( ) ) ) . p as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( dsa_params ) , "::" , stringify ! ( p ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_params > ( ) ) ) . q as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( dsa_params ) , "::" , stringify ! ( q ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_params > ( ) ) ) . g as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( dsa_params ) , "::" , stringify ! ( g ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_params_init" ] pub fn nettle_dsa_params_init ( params : * mut dsa_params ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_params_clear" ] pub fn nettle_dsa_params_clear ( params : * mut dsa_params ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct dsa_signature { pub r : mpz_t , pub s : mpz_t , } # [ test ] fn bindgen_test_layout_dsa_signature ( ) { assert_eq ! ( :: std :: mem :: size_of :: < dsa_signature > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( dsa_signature ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < dsa_signature > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( dsa_signature ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_signature > ( ) ) ) . r as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( dsa_signature ) , "::" , stringify ! ( r ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_signature > ( ) ) ) . s as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( dsa_signature ) , "::" , stringify ! ( s ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_signature_init" ] pub fn nettle_dsa_signature_init ( signature : * mut dsa_signature ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_signature_clear" ] pub fn nettle_dsa_signature_clear ( signature : * mut dsa_signature ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sign" ] pub fn nettle_dsa_sign ( params : * const dsa_params , x : * mut __mpz_struct , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest_size : usize , digest : * const u8 , signature : * mut dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_verify" ] pub fn nettle_dsa_verify ( params : * const dsa_params , y : * mut __mpz_struct , digest_size : usize , digest : * const u8 , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_generate_params" ] pub fn nettle_dsa_generate_params ( params : * mut dsa_params , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , progress_ctx : * mut :: std :: os :: raw :: c_void , progress : nettle_progress_func , p_bits : :: std :: os :: raw :: c_uint , q_bits : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_generate_keypair" ] pub fn nettle_dsa_generate_keypair ( params : * const dsa_params , pub_ : * mut __mpz_struct , key : * mut __mpz_struct , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_keypair_to_sexp" ] pub fn nettle_dsa_keypair_to_sexp ( buffer : * mut nettle_buffer , algorithm_name : * const :: std :: os :: raw :: c_char , params : * const dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_signature_from_sexp" ] pub fn nettle_dsa_signature_from_sexp ( rs : * mut dsa_signature , i : * mut sexp_iterator , q_bits : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_keypair_from_sexp_alist" ] pub fn nettle_dsa_keypair_from_sexp_alist ( params : * mut dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct , p_max_bits : :: std :: os :: raw :: c_uint , q_bits : :: std :: os :: raw :: c_uint , i : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha1_keypair_from_sexp" ] pub fn nettle_dsa_sha1_keypair_from_sexp ( params : * mut dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct , p_max_bits : :: std :: os :: raw :: c_uint , length : usize , expr : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha256_keypair_from_sexp" ] pub fn nettle_dsa_sha256_keypair_from_sexp ( params : * mut dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct , p_max_bits : :: std :: os :: raw :: c_uint , length : usize , expr : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_params_from_der_iterator" ] pub fn nettle_dsa_params_from_der_iterator ( params : * mut dsa_params , max_bits : :: std :: os :: raw :: c_uint , q_bits : :: std :: os :: raw :: c_uint , i : * mut asn1_der_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_public_key_from_der_iterator" ] pub fn nettle_dsa_public_key_from_der_iterator ( params : * const dsa_params , pub_ : * mut __mpz_struct , i : * mut asn1_der_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_openssl_private_key_from_der_iterator" ] pub fn nettle_dsa_openssl_private_key_from_der_iterator ( params : * mut dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct , p_max_bits : :: std :: os :: raw :: c_uint , i : * mut asn1_der_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_openssl_provate_key_from_der" ] pub fn nettle_openssl_provate_key_from_der ( params : * mut dsa_params , pub_ : * mut __mpz_struct , priv_ : * mut __mpz_struct , p_max_bits : :: std :: os :: raw :: c_uint , length : usize , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_dsa_hash" ] pub fn _nettle_dsa_hash ( h : * mut __mpz_struct , bit_size : :: std :: os :: raw :: c_uint , length : usize , digest : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha1_ctx { pub state : [ u32 ; 5usize ] , pub count : u64 , pub block : [ u8 ; 64usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_sha1_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha1_ctx > ( ) , 104usize , concat ! ( "Size of: " , stringify ! ( sha1_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha1_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha1_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha1_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha1_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha1_ctx > ( ) ) ) . count as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( sha1_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha1_ctx > ( ) ) ) . block as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( sha1_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha1_ctx > ( ) ) ) . index as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( sha1_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha1_init" ] pub fn nettle_sha1_init ( ctx : * mut sha1_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha1_update" ] pub fn nettle_sha1_update ( ctx : * mut sha1_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha1_digest" ] pub fn nettle_sha1_digest ( ctx : * mut sha1_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_sha1_compress" ] pub fn _nettle_sha1_compress ( state : * mut u32 , data : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha256_ctx { pub state : [ u32 ; 8usize ] , pub count : u64 , pub block : [ u8 ; 64usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_sha256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha256_ctx > ( ) , 112usize , concat ! ( "Size of: " , stringify ! ( sha256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha256_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha256_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha256_ctx > ( ) ) ) . count as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( sha256_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha256_ctx > ( ) ) ) . block as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( sha256_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha256_ctx > ( ) ) ) . index as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( sha256_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha256_init" ] pub fn nettle_sha256_init ( ctx : * mut sha256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha256_update" ] pub fn nettle_sha256_update ( ctx : * mut sha256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha256_digest" ] pub fn nettle_sha256_digest ( ctx : * mut sha256_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_sha256_compress" ] pub fn _nettle_sha256_compress ( state : * mut u32 , data : * const u8 , k : * const u32 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha224_init" ] pub fn nettle_sha224_init ( ctx : * mut sha256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha224_digest" ] pub fn nettle_sha224_digest ( ctx : * mut sha256_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha512_ctx { pub state : [ u64 ; 8usize ] , pub count_low : u64 , pub count_high : u64 , pub block : [ u8 ; 128usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_sha512_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha512_ctx > ( ) , 216usize , concat ! ( "Size of: " , stringify ! ( sha512_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha512_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha512_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha512_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha512_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha512_ctx > ( ) ) ) . count_low as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( sha512_ctx ) , "::" , stringify ! ( count_low ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha512_ctx > ( ) ) ) . count_high as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( sha512_ctx ) , "::" , stringify ! ( count_high ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha512_ctx > ( ) ) ) . block as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( sha512_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha512_ctx > ( ) ) ) . index as * const _ as usize } , 208usize , concat ! ( "Offset of field: " , stringify ! ( sha512_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_init" ] pub fn nettle_sha512_init ( ctx : * mut sha512_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_update" ] pub fn nettle_sha512_update ( ctx : * mut sha512_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_digest" ] pub fn nettle_sha512_digest ( ctx : * mut sha512_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_sha512_compress" ] pub fn _nettle_sha512_compress ( state : * mut u64 , data : * const u8 , k : * const u64 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha384_init" ] pub fn nettle_sha384_init ( ctx : * mut sha512_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha384_digest" ] pub fn nettle_sha384_digest ( ctx : * mut sha512_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_224_init" ] pub fn nettle_sha512_224_init ( ctx : * mut sha512_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_224_digest" ] pub fn nettle_sha512_224_digest ( ctx : * mut sha512_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_256_init" ] pub fn nettle_sha512_256_init ( ctx : * mut sha512_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha512_256_digest" ] pub fn nettle_sha512_256_digest ( ctx : * mut sha512_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct dsa_public_key { pub p : mpz_t , pub q : mpz_t , pub g : mpz_t , pub y : mpz_t , } # [ test ] fn bindgen_test_layout_dsa_public_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < dsa_public_key > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( dsa_public_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < dsa_public_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( dsa_public_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_public_key > ( ) ) ) . p as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( dsa_public_key ) , "::" , stringify ! ( p ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_public_key > ( ) ) ) . q as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( dsa_public_key ) , "::" , stringify ! ( q ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_public_key > ( ) ) ) . g as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( dsa_public_key ) , "::" , stringify ! ( g ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_public_key > ( ) ) ) . y as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( dsa_public_key ) , "::" , stringify ! ( y ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct dsa_private_key { pub x : mpz_t , } # [ test ] fn bindgen_test_layout_dsa_private_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < dsa_private_key > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( dsa_private_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < dsa_private_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( dsa_private_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < dsa_private_key > ( ) ) ) . x as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( dsa_private_key ) , "::" , stringify ! ( x ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_public_key_init" ] pub fn nettle_dsa_public_key_init ( key : * mut dsa_public_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_public_key_clear" ] pub fn nettle_dsa_public_key_clear ( key : * mut dsa_public_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_private_key_init" ] pub fn nettle_dsa_private_key_init ( key : * mut dsa_private_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_private_key_clear" ] pub fn nettle_dsa_private_key_clear ( key : * mut dsa_private_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha1_sign" ] pub fn nettle_dsa_sha1_sign ( pub_ : * const dsa_public_key , key : * const dsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut sha1_ctx , signature : * mut dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha256_sign" ] pub fn nettle_dsa_sha256_sign ( pub_ : * const dsa_public_key , key : * const dsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut sha256_ctx , signature : * mut dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha1_verify" ] pub fn nettle_dsa_sha1_verify ( key : * const dsa_public_key , hash : * mut sha1_ctx , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha256_verify" ] pub fn nettle_dsa_sha256_verify ( key : * const dsa_public_key , hash : * mut sha256_ctx , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha1_sign_digest" ] pub fn nettle_dsa_sha1_sign_digest ( pub_ : * const dsa_public_key , key : * const dsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , signature : * mut dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha256_sign_digest" ] pub fn nettle_dsa_sha256_sign_digest ( pub_ : * const dsa_public_key , key : * const dsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , signature : * mut dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha1_verify_digest" ] pub fn nettle_dsa_sha1_verify_digest ( key : * const dsa_public_key , digest : * const u8 , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_sha256_verify_digest" ] pub fn nettle_dsa_sha256_verify_digest ( key : * const dsa_public_key , digest : * const u8 , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_dsa_compat_generate_keypair" ] pub fn nettle_dsa_compat_generate_keypair ( pub_ : * mut dsa_public_key , key : * mut dsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , progress_ctx : * mut :: std :: os :: raw :: c_void , progress : nettle_progress_func , p_bits : :: std :: os :: raw :: c_uint , q_bits : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct eax_key { pub pad_block : nettle_block16 , pub pad_partial : nettle_block16 , } # [ test ] fn bindgen_test_layout_eax_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < eax_key > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( eax_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < eax_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( eax_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_key > ( ) ) ) . pad_block as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( eax_key ) , "::" , stringify ! ( pad_block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_key > ( ) ) ) . pad_partial as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( eax_key ) , "::" , stringify ! ( pad_partial ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct eax_ctx { pub omac_nonce : nettle_block16 , pub omac_data : nettle_block16 , pub omac_message : nettle_block16 , pub ctr : nettle_block16 , } # [ test ] fn bindgen_test_layout_eax_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < eax_ctx > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( eax_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < eax_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( eax_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_ctx > ( ) ) ) . omac_nonce as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( eax_ctx ) , "::" , stringify ! ( omac_nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_ctx > ( ) ) ) . omac_data as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( eax_ctx ) , "::" , stringify ! ( omac_data ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_ctx > ( ) ) ) . omac_message as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( eax_ctx ) , "::" , stringify ! ( omac_message ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_ctx > ( ) ) ) . ctr as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( eax_ctx ) , "::" , stringify ! ( ctr ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_set_key" ] pub fn nettle_eax_set_key ( key : * mut eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_set_nonce" ] pub fn nettle_eax_set_nonce ( eax : * mut eax_ctx , key : * const eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , nonce_length : usize , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_update" ] pub fn nettle_eax_update ( eax : * mut eax_ctx , key : * const eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , data_length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_encrypt" ] pub fn nettle_eax_encrypt ( eax : * mut eax_ctx , key : * const eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_decrypt" ] pub fn nettle_eax_decrypt ( eax : * mut eax_ctx , key : * const eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_digest" ] pub fn nettle_eax_digest ( eax : * mut eax_ctx , key : * const eax_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct eax_aes128_ctx { pub key : eax_key , pub eax : eax_ctx , pub cipher : aes128_ctx , } # [ test ] fn bindgen_test_layout_eax_aes128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < eax_aes128_ctx > ( ) , 272usize , concat ! ( "Size of: " , stringify ! ( eax_aes128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < eax_aes128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( eax_aes128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_aes128_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( eax_aes128_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_aes128_ctx > ( ) ) ) . eax as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( eax_aes128_ctx ) , "::" , stringify ! ( eax ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < eax_aes128_ctx > ( ) ) ) . cipher as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( eax_aes128_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_set_key" ] pub fn nettle_eax_aes128_set_key ( ctx : * mut eax_aes128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_set_nonce" ] pub fn nettle_eax_aes128_set_nonce ( ctx : * mut eax_aes128_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_update" ] pub fn nettle_eax_aes128_update ( ctx : * mut eax_aes128_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_encrypt" ] pub fn nettle_eax_aes128_encrypt ( ctx : * mut eax_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_decrypt" ] pub fn nettle_eax_aes128_decrypt ( ctx : * mut eax_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_eax_aes128_digest" ] pub fn nettle_eax_aes128_digest ( ctx : * mut eax_aes128_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ecc_curve { _unused : [ u8 ; 0 ] , } extern "C" { # [ link_name = "\u{1}_nettle_secp_192r1" ] pub static nettle_secp_192r1 : ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_secp_224r1" ] pub static nettle_secp_224r1 : ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_secp_256r1" ] pub static nettle_secp_256r1 : ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_secp_384r1" ] pub static nettle_secp_384r1 : ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_secp_521r1" ] pub static nettle_secp_521r1 : ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_get_secp_192r1" ] pub fn nettle_get_secp_192r1 ( ) -> * const ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_get_secp_224r1" ] pub fn nettle_get_secp_224r1 ( ) -> * const ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_get_secp_256r1" ] pub fn nettle_get_secp_256r1 ( ) -> * const ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_get_secp_384r1" ] pub fn nettle_get_secp_384r1 ( ) -> * const ecc_curve ; } extern "C" { # [ link_name = "\u{1}_nettle_get_secp_521r1" ] pub fn nettle_get_secp_521r1 ( ) -> * const ecc_curve ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ecc_point { pub ecc : * const ecc_curve , pub p : * mut mp_limb_t , } # [ test ] fn bindgen_test_layout_ecc_point ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ecc_point > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( ecc_point ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ecc_point > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ecc_point ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ecc_point > ( ) ) ) . ecc as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ecc_point ) , "::" , stringify ! ( ecc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ecc_point > ( ) ) ) . p as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( ecc_point ) , "::" , stringify ! ( p ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ecc_scalar { pub ecc : * const ecc_curve , pub p : * mut mp_limb_t , } # [ test ] fn bindgen_test_layout_ecc_scalar ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ecc_scalar > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( ecc_scalar ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ecc_scalar > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ecc_scalar ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ecc_scalar > ( ) ) ) . ecc as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ecc_scalar ) , "::" , stringify ! ( ecc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ecc_scalar > ( ) ) ) . p as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( ecc_scalar ) , "::" , stringify ! ( p ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_init" ] pub fn nettle_ecc_point_init ( p : * mut ecc_point , ecc : * const ecc_curve ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_clear" ] pub fn nettle_ecc_point_clear ( p : * mut ecc_point ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_set" ] pub fn nettle_ecc_point_set ( p : * mut ecc_point , x : * mut __mpz_struct , y : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_get" ] pub fn nettle_ecc_point_get ( p : * const ecc_point , x : * mut __mpz_struct , y : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_scalar_init" ] pub fn nettle_ecc_scalar_init ( s : * mut ecc_scalar , ecc : * const ecc_curve ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_scalar_clear" ] pub fn nettle_ecc_scalar_clear ( s : * mut ecc_scalar ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_scalar_set" ] pub fn nettle_ecc_scalar_set ( s : * mut ecc_scalar , z : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_scalar_get" ] pub fn nettle_ecc_scalar_get ( s : * const ecc_scalar , z : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_scalar_random" ] pub fn nettle_ecc_scalar_random ( s : * mut ecc_scalar , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_mul" ] pub fn nettle_ecc_point_mul ( r : * mut ecc_point , n : * const ecc_scalar , p : * const ecc_point ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_point_mul_g" ] pub fn nettle_ecc_point_mul_g ( r : * mut ecc_point , n : * const ecc_scalar ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_bit_size" ] pub fn nettle_ecc_bit_size ( ecc : * const ecc_curve ) -> :: std :: os :: raw :: c_uint ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_size" ] pub fn nettle_ecc_size ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_size_a" ] pub fn nettle_ecc_size_a ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_size_j" ] pub fn nettle_ecc_size_j ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}_nettle_ecdsa_sign" ] pub fn nettle_ecdsa_sign ( key : * const ecc_scalar , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest_length : usize , digest : * const u8 , signature : * mut dsa_signature ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecdsa_verify" ] pub fn nettle_ecdsa_verify ( pub_ : * const ecc_point , length : usize , digest : * const u8 , signature : * const dsa_signature ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_ecdsa_generate_keypair" ] pub fn nettle_ecdsa_generate_keypair ( pub_ : * mut ecc_point , key : * mut ecc_scalar , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_ecdsa_sign_itch" ] pub fn nettle_ecc_ecdsa_sign_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_ecdsa_sign" ] pub fn nettle_ecc_ecdsa_sign ( ecc : * const ecc_curve , zp : * const mp_limb_t , kp : * const mp_limb_t , length : usize , digest : * const u8 , rp : * mut mp_limb_t , sp : * mut mp_limb_t , scratch : * mut mp_limb_t ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_ecdsa_verify_itch" ] pub fn nettle_ecc_ecdsa_verify_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}_nettle_ecc_ecdsa_verify" ] pub fn nettle_ecc_ecdsa_verify ( ecc : * const ecc_curve , pp : * const mp_limb_t , length : usize , digest : * const u8 , rp : * const mp_limb_t , sp : * const mp_limb_t , scratch : * mut mp_limb_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_ed25519_sha512_public_key" ] pub fn nettle_ed25519_sha512_public_key ( pub_ : * mut u8 , priv_ : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ed25519_sha512_sign" ] pub fn nettle_ed25519_sha512_sign ( pub_ : * const u8 , priv_ : * const u8 , length : usize , msg : * const u8 , signature : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ed25519_sha512_verify" ] pub fn nettle_ed25519_sha512_verify ( pub_ : * const u8 , length : usize , msg : * const u8 , signature : * const u8 ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ecc_modulo { _unused : [ u8 ; 0 ] , } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_compress_itch" ] pub fn _nettle_eddsa_compress_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_compress" ] pub fn _nettle_eddsa_compress ( ecc : * const ecc_curve , r : * mut u8 , p : * mut mp_limb_t , scratch : * mut mp_limb_t ) ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_decompress_itch" ] pub fn _nettle_eddsa_decompress_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_decompress" ] pub fn _nettle_eddsa_decompress ( ecc : * const ecc_curve , p : * mut mp_limb_t , cp : * const u8 , scratch : * mut mp_limb_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_hash" ] pub fn _nettle_eddsa_hash ( m : * const ecc_modulo , rp : * mut mp_limb_t , digest : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_sign_itch" ] pub fn _nettle_eddsa_sign_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_sign" ] pub fn _nettle_eddsa_sign ( ecc : * const ecc_curve , H : * const nettle_hash , pub_ : * const u8 , ctx : * mut :: std :: os :: raw :: c_void , k2 : * const mp_limb_t , length : usize , msg : * const u8 , signature : * mut u8 , scratch : * mut mp_limb_t ) ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_verify_itch" ] pub fn _nettle_eddsa_verify_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_verify" ] pub fn _nettle_eddsa_verify ( ecc : * const ecc_curve , H : * const nettle_hash , pub_ : * const u8 , A : * const mp_limb_t , ctx : * mut :: std :: os :: raw :: c_void , length : usize , msg : * const u8 , signature : * const u8 , scratch : * mut mp_limb_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_expand_key" ] pub fn _nettle_eddsa_expand_key ( ecc : * const ecc_curve , H : * const nettle_hash , ctx : * mut :: std :: os :: raw :: c_void , key : * const u8 , digest : * mut u8 , k2 : * mut mp_limb_t ) ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_public_key_itch" ] pub fn _nettle_eddsa_public_key_itch ( ecc : * const ecc_curve ) -> mp_size_t ; } extern "C" { # [ link_name = "\u{1}__nettle_eddsa_public_key" ] pub fn _nettle_eddsa_public_key ( ecc : * const ecc_curve , k : * const mp_limb_t , pub_ : * mut u8 , scratch : * mut mp_limb_t ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_key { pub h : [ nettle_block16 ; 256usize ] , } # [ test ] fn bindgen_test_layout_gcm_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_key > ( ) , 4096usize , concat ! ( "Size of: " , stringify ! ( gcm_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_key > ( ) ) ) . h as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_key ) , "::" , stringify ! ( h ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_ctx { pub iv : nettle_block16 , pub ctr : nettle_block16 , pub x : nettle_block16 , pub auth_size : u64 , pub data_size : u64 , } # [ test ] fn bindgen_test_layout_gcm_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_ctx > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( gcm_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_ctx > ( ) ) ) . iv as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_ctx ) , "::" , stringify ! ( iv ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_ctx > ( ) ) ) . ctr as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( gcm_ctx ) , "::" , stringify ! ( ctr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_ctx > ( ) ) ) . x as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( gcm_ctx ) , "::" , stringify ! ( x ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_ctx > ( ) ) ) . auth_size as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( gcm_ctx ) , "::" , stringify ! ( auth_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_ctx > ( ) ) ) . data_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( gcm_ctx ) , "::" , stringify ! ( data_size ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_set_key" ] pub fn nettle_gcm_set_key ( key : * mut gcm_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_set_iv" ] pub fn nettle_gcm_set_iv ( ctx : * mut gcm_ctx , key : * const gcm_key , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_update" ] pub fn nettle_gcm_update ( ctx : * mut gcm_ctx , key : * const gcm_key , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_encrypt" ] pub fn nettle_gcm_encrypt ( ctx : * mut gcm_ctx , key : * const gcm_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_decrypt" ] pub fn nettle_gcm_decrypt ( ctx : * mut gcm_ctx , key : * const gcm_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_digest" ] pub fn nettle_gcm_digest ( ctx : * mut gcm_ctx , key : * const gcm_key , cipher : * const :: std :: os :: raw :: c_void , f : nettle_cipher_func , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_aes128_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : aes128_ctx , } # [ test ] fn bindgen_test_layout_gcm_aes128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_aes128_ctx > ( ) , 4336usize , concat ! ( "Size of: " , stringify ! ( gcm_aes128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_aes128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_aes128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes128_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes128_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes128_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes128_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes128_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes128_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_set_key" ] pub fn nettle_gcm_aes128_set_key ( ctx : * mut gcm_aes128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_update" ] pub fn nettle_gcm_aes128_update ( ctx : * mut gcm_aes128_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_set_iv" ] pub fn nettle_gcm_aes128_set_iv ( ctx : * mut gcm_aes128_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_encrypt" ] pub fn nettle_gcm_aes128_encrypt ( ctx : * mut gcm_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_decrypt" ] pub fn nettle_gcm_aes128_decrypt ( ctx : * mut gcm_aes128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes128_digest" ] pub fn nettle_gcm_aes128_digest ( ctx : * mut gcm_aes128_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_aes192_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : aes192_ctx , } # [ test ] fn bindgen_test_layout_gcm_aes192_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_aes192_ctx > ( ) , 4368usize , concat ! ( "Size of: " , stringify ! ( gcm_aes192_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_aes192_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_aes192_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes192_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes192_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes192_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes192_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes192_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes192_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_set_key" ] pub fn nettle_gcm_aes192_set_key ( ctx : * mut gcm_aes192_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_update" ] pub fn nettle_gcm_aes192_update ( ctx : * mut gcm_aes192_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_set_iv" ] pub fn nettle_gcm_aes192_set_iv ( ctx : * mut gcm_aes192_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_encrypt" ] pub fn nettle_gcm_aes192_encrypt ( ctx : * mut gcm_aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_decrypt" ] pub fn nettle_gcm_aes192_decrypt ( ctx : * mut gcm_aes192_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes192_digest" ] pub fn nettle_gcm_aes192_digest ( ctx : * mut gcm_aes192_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_aes256_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : aes256_ctx , } # [ test ] fn bindgen_test_layout_gcm_aes256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_aes256_ctx > ( ) , 4400usize , concat ! ( "Size of: " , stringify ! ( gcm_aes256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_aes256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_aes256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes256_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes256_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes256_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes256_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes256_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes256_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_set_key" ] pub fn nettle_gcm_aes256_set_key ( ctx : * mut gcm_aes256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_update" ] pub fn nettle_gcm_aes256_update ( ctx : * mut gcm_aes256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_set_iv" ] pub fn nettle_gcm_aes256_set_iv ( ctx : * mut gcm_aes256_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_encrypt" ] pub fn nettle_gcm_aes256_encrypt ( ctx : * mut gcm_aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_decrypt" ] pub fn nettle_gcm_aes256_decrypt ( ctx : * mut gcm_aes256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes256_digest" ] pub fn nettle_gcm_aes256_digest ( ctx : * mut gcm_aes256_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_aes_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : aes_ctx , } # [ test ] fn bindgen_test_layout_gcm_aes_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_aes_ctx > ( ) , 4408usize , concat ! ( "Size of: " , stringify ! ( gcm_aes_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_aes_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_aes_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_aes_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_aes_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_set_key" ] pub fn nettle_gcm_aes_set_key ( ctx : * mut gcm_aes_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_set_iv" ] pub fn nettle_gcm_aes_set_iv ( ctx : * mut gcm_aes_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_update" ] pub fn nettle_gcm_aes_update ( ctx : * mut gcm_aes_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_encrypt" ] pub fn nettle_gcm_aes_encrypt ( ctx : * mut gcm_aes_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_decrypt" ] pub fn nettle_gcm_aes_decrypt ( ctx : * mut gcm_aes_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_aes_digest" ] pub fn nettle_gcm_aes_digest ( ctx : * mut gcm_aes_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_camellia128_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : camellia128_ctx , } # [ test ] fn bindgen_test_layout_gcm_camellia128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_camellia128_ctx > ( ) , 4352usize , concat ! ( "Size of: " , stringify ! ( gcm_camellia128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_camellia128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_camellia128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia128_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia128_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia128_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia128_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia128_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia128_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_set_key" ] pub fn nettle_gcm_camellia128_set_key ( ctx : * mut gcm_camellia128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_set_iv" ] pub fn nettle_gcm_camellia128_set_iv ( ctx : * mut gcm_camellia128_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_update" ] pub fn nettle_gcm_camellia128_update ( ctx : * mut gcm_camellia128_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_encrypt" ] pub fn nettle_gcm_camellia128_encrypt ( ctx : * mut gcm_camellia128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_decrypt" ] pub fn nettle_gcm_camellia128_decrypt ( ctx : * mut gcm_camellia128_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia128_digest" ] pub fn nettle_gcm_camellia128_digest ( ctx : * mut gcm_camellia128_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct gcm_camellia256_ctx { pub key : gcm_key , pub gcm : gcm_ctx , pub cipher : camellia256_ctx , } # [ test ] fn bindgen_test_layout_gcm_camellia256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gcm_camellia256_ctx > ( ) , 4416usize , concat ! ( "Size of: " , stringify ! ( gcm_camellia256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gcm_camellia256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gcm_camellia256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia256_ctx > ( ) ) ) . key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia256_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia256_ctx > ( ) ) ) . gcm as * const _ as usize } , 4096usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia256_ctx ) , "::" , stringify ! ( gcm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gcm_camellia256_ctx > ( ) ) ) . cipher as * const _ as usize } , 4160usize , concat ! ( "Offset of field: " , stringify ! ( gcm_camellia256_ctx ) , "::" , stringify ! ( cipher ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_set_key" ] pub fn nettle_gcm_camellia256_set_key ( ctx : * mut gcm_camellia256_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_set_iv" ] pub fn nettle_gcm_camellia256_set_iv ( ctx : * mut gcm_camellia256_ctx , length : usize , iv : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_update" ] pub fn nettle_gcm_camellia256_update ( ctx : * mut gcm_camellia256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_encrypt" ] pub fn nettle_gcm_camellia256_encrypt ( ctx : * mut gcm_camellia256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_decrypt" ] pub fn nettle_gcm_camellia256_decrypt ( ctx : * mut gcm_camellia256_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gcm_camellia256_digest" ] pub fn nettle_gcm_camellia256_digest ( ctx : * mut gcm_camellia256_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct gosthash94_ctx { pub hash : [ u32 ; 8usize ] , pub sum : [ u32 ; 8usize ] , pub message : [ u8 ; 32usize ] , pub length : u64 , } # [ test ] fn bindgen_test_layout_gosthash94_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < gosthash94_ctx > ( ) , 104usize , concat ! ( "Size of: " , stringify ! ( gosthash94_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < gosthash94_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( gosthash94_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gosthash94_ctx > ( ) ) ) . hash as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( gosthash94_ctx ) , "::" , stringify ! ( hash ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gosthash94_ctx > ( ) ) ) . sum as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( gosthash94_ctx ) , "::" , stringify ! ( sum ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gosthash94_ctx > ( ) ) ) . message as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( gosthash94_ctx ) , "::" , stringify ! ( message ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < gosthash94_ctx > ( ) ) ) . length as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( gosthash94_ctx ) , "::" , stringify ! ( length ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gosthash94_init" ] pub fn nettle_gosthash94_init ( ctx : * mut gosthash94_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gosthash94_update" ] pub fn nettle_gosthash94_update ( ctx : * mut gosthash94_ctx , length : usize , msg : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_gosthash94_digest" ] pub fn nettle_gosthash94_digest ( ctx : * mut gosthash94_ctx , length : usize , result : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hkdf_extract" ] pub fn nettle_hkdf_extract ( mac_ctx : * mut :: std :: os :: raw :: c_void , update : nettle_hash_update_func , digest : nettle_hash_digest_func , digest_size : usize , secret_size : usize , secret : * const u8 , dst : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hkdf_expand" ] pub fn nettle_hkdf_expand ( mac_ctx : * mut :: std :: os :: raw :: c_void , update : nettle_hash_update_func , digest : nettle_hash_digest_func , digest_size : usize , info_size : usize , info : * const u8 , length : usize , dst : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct md5_ctx { pub state : [ u32 ; 4usize ] , pub count : u64 , pub block : [ u8 ; 64usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_md5_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < md5_ctx > ( ) , 96usize , concat ! ( "Size of: " , stringify ! ( md5_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < md5_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( md5_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md5_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( md5_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md5_ctx > ( ) ) ) . count as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( md5_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md5_ctx > ( ) ) ) . block as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( md5_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md5_ctx > ( ) ) ) . index as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( md5_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md5_init" ] pub fn nettle_md5_init ( ctx : * mut md5_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md5_update" ] pub fn nettle_md5_update ( ctx : * mut md5_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md5_digest" ] pub fn nettle_md5_digest ( ctx : * mut md5_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_md5_compress" ] pub fn _nettle_md5_compress ( state : * mut u32 , data : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct ripemd160_ctx { pub state : [ u32 ; 5usize ] , pub count : u64 , pub block : [ u8 ; 64usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_ripemd160_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ripemd160_ctx > ( ) , 104usize , concat ! ( "Size of: " , stringify ! ( ripemd160_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ripemd160_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ripemd160_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ripemd160_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ripemd160_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ripemd160_ctx > ( ) ) ) . count as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( ripemd160_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ripemd160_ctx > ( ) ) ) . block as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( ripemd160_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ripemd160_ctx > ( ) ) ) . index as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( ripemd160_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ripemd160_init" ] pub fn nettle_ripemd160_init ( ctx : * mut ripemd160_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ripemd160_update" ] pub fn nettle_ripemd160_update ( ctx : * mut ripemd160_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_ripemd160_digest" ] pub fn nettle_ripemd160_digest ( ctx : * mut ripemd160_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_ripemd160_compress" ] pub fn _nettle_ripemd160_compress ( state : * mut u32 , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_set_key" ] pub fn nettle_hmac_set_key ( outer : * mut :: std :: os :: raw :: c_void , inner : * mut :: std :: os :: raw :: c_void , state : * mut :: std :: os :: raw :: c_void , hash : * const nettle_hash , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_update" ] pub fn nettle_hmac_update ( state : * mut :: std :: os :: raw :: c_void , hash : * const nettle_hash , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_digest" ] pub fn nettle_hmac_digest ( outer : * const :: std :: os :: raw :: c_void , inner : * const :: std :: os :: raw :: c_void , state : * mut :: std :: os :: raw :: c_void , hash : * const nettle_hash , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct hmac_md5_ctx { pub outer : md5_ctx , pub inner : md5_ctx , pub state : md5_ctx , } # [ test ] fn bindgen_test_layout_hmac_md5_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < hmac_md5_ctx > ( ) , 288usize , concat ! ( "Size of: " , stringify ! ( hmac_md5_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < hmac_md5_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( hmac_md5_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_md5_ctx > ( ) ) ) . outer as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( hmac_md5_ctx ) , "::" , stringify ! ( outer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_md5_ctx > ( ) ) ) . inner as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( hmac_md5_ctx ) , "::" , stringify ! ( inner ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_md5_ctx > ( ) ) ) . state as * const _ as usize } , 192usize , concat ! ( "Offset of field: " , stringify ! ( hmac_md5_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_md5_set_key" ] pub fn nettle_hmac_md5_set_key ( ctx : * mut hmac_md5_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_md5_update" ] pub fn nettle_hmac_md5_update ( ctx : * mut hmac_md5_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_md5_digest" ] pub fn nettle_hmac_md5_digest ( ctx : * mut hmac_md5_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct hmac_ripemd160_ctx { pub outer : ripemd160_ctx , pub inner : ripemd160_ctx , pub state : ripemd160_ctx , } # [ test ] fn bindgen_test_layout_hmac_ripemd160_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < hmac_ripemd160_ctx > ( ) , 312usize , concat ! ( "Size of: " , stringify ! ( hmac_ripemd160_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < hmac_ripemd160_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( hmac_ripemd160_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_ripemd160_ctx > ( ) ) ) . outer as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( hmac_ripemd160_ctx ) , "::" , stringify ! ( outer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_ripemd160_ctx > ( ) ) ) . inner as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( hmac_ripemd160_ctx ) , "::" , stringify ! ( inner ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_ripemd160_ctx > ( ) ) ) . state as * const _ as usize } , 208usize , concat ! ( "Offset of field: " , stringify ! ( hmac_ripemd160_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_ripemd160_set_key" ] pub fn nettle_hmac_ripemd160_set_key ( ctx : * mut hmac_ripemd160_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_ripemd160_update" ] pub fn nettle_hmac_ripemd160_update ( ctx : * mut hmac_ripemd160_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_ripemd160_digest" ] pub fn nettle_hmac_ripemd160_digest ( ctx : * mut hmac_ripemd160_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct hmac_sha1_ctx { pub outer : sha1_ctx , pub inner : sha1_ctx , pub state : sha1_ctx , } # [ test ] fn bindgen_test_layout_hmac_sha1_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < hmac_sha1_ctx > ( ) , 312usize , concat ! ( "Size of: " , stringify ! ( hmac_sha1_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < hmac_sha1_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( hmac_sha1_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha1_ctx > ( ) ) ) . outer as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha1_ctx ) , "::" , stringify ! ( outer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha1_ctx > ( ) ) ) . inner as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha1_ctx ) , "::" , stringify ! ( inner ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha1_ctx > ( ) ) ) . state as * const _ as usize } , 208usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha1_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha1_set_key" ] pub fn nettle_hmac_sha1_set_key ( ctx : * mut hmac_sha1_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha1_update" ] pub fn nettle_hmac_sha1_update ( ctx : * mut hmac_sha1_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha1_digest" ] pub fn nettle_hmac_sha1_digest ( ctx : * mut hmac_sha1_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct hmac_sha256_ctx { pub outer : sha256_ctx , pub inner : sha256_ctx , pub state : sha256_ctx , } # [ test ] fn bindgen_test_layout_hmac_sha256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < hmac_sha256_ctx > ( ) , 336usize , concat ! ( "Size of: " , stringify ! ( hmac_sha256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < hmac_sha256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( hmac_sha256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha256_ctx > ( ) ) ) . outer as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha256_ctx ) , "::" , stringify ! ( outer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha256_ctx > ( ) ) ) . inner as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha256_ctx ) , "::" , stringify ! ( inner ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha256_ctx > ( ) ) ) . state as * const _ as usize } , 224usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha256_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha256_set_key" ] pub fn nettle_hmac_sha256_set_key ( ctx : * mut hmac_sha256_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha256_update" ] pub fn nettle_hmac_sha256_update ( ctx : * mut hmac_sha256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha256_digest" ] pub fn nettle_hmac_sha256_digest ( ctx : * mut hmac_sha256_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha224_set_key" ] pub fn nettle_hmac_sha224_set_key ( ctx : * mut hmac_sha256_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha224_digest" ] pub fn nettle_hmac_sha224_digest ( ctx : * mut hmac_sha256_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct hmac_sha512_ctx { pub outer : sha512_ctx , pub inner : sha512_ctx , pub state : sha512_ctx , } # [ test ] fn bindgen_test_layout_hmac_sha512_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < hmac_sha512_ctx > ( ) , 648usize , concat ! ( "Size of: " , stringify ! ( hmac_sha512_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < hmac_sha512_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( hmac_sha512_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha512_ctx > ( ) ) ) . outer as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha512_ctx ) , "::" , stringify ! ( outer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha512_ctx > ( ) ) ) . inner as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha512_ctx ) , "::" , stringify ! ( inner ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < hmac_sha512_ctx > ( ) ) ) . state as * const _ as usize } , 432usize , concat ! ( "Offset of field: " , stringify ! ( hmac_sha512_ctx ) , "::" , stringify ! ( state ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha512_set_key" ] pub fn nettle_hmac_sha512_set_key ( ctx : * mut hmac_sha512_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha512_update" ] pub fn nettle_hmac_sha512_update ( ctx : * mut hmac_sha512_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha512_digest" ] pub fn nettle_hmac_sha512_digest ( ctx : * mut hmac_sha512_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha384_set_key" ] pub fn nettle_hmac_sha384_set_key ( ctx : * mut hmac_sha512_ctx , key_length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_hmac_sha384_digest" ] pub fn nettle_hmac_sha384_digest ( ctx : * mut hmac_sha512_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct knuth_lfib_ctx { pub x : [ u32 ; 100usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_knuth_lfib_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < knuth_lfib_ctx > ( ) , 404usize , concat ! ( "Size of: " , stringify ! ( knuth_lfib_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < knuth_lfib_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( knuth_lfib_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < knuth_lfib_ctx > ( ) ) ) . x as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( knuth_lfib_ctx ) , "::" , stringify ! ( x ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < knuth_lfib_ctx > ( ) ) ) . index as * const _ as usize } , 400usize , concat ! ( "Offset of field: " , stringify ! ( knuth_lfib_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_knuth_lfib_init" ] pub fn nettle_knuth_lfib_init ( ctx : * mut knuth_lfib_ctx , seed : u32 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_knuth_lfib_get" ] pub fn nettle_knuth_lfib_get ( ctx : * mut knuth_lfib_ctx ) -> u32 ; } extern "C" { # [ link_name = "\u{1}_nettle_knuth_lfib_get_array" ] pub fn nettle_knuth_lfib_get_array ( ctx : * mut knuth_lfib_ctx , n : usize , a : * mut u32 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_knuth_lfib_random" ] pub fn nettle_knuth_lfib_random ( ctx : * mut knuth_lfib_ctx , n : usize , dst : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct md2_ctx { pub C : [ u8 ; 16usize ] , pub X : [ u8 ; 48usize ] , pub block : [ u8 ; 16usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_md2_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < md2_ctx > ( ) , 84usize , concat ! ( "Size of: " , stringify ! ( md2_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < md2_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( md2_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md2_ctx > ( ) ) ) . C as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( md2_ctx ) , "::" , stringify ! ( C ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md2_ctx > ( ) ) ) . X as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( md2_ctx ) , "::" , stringify ! ( X ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md2_ctx > ( ) ) ) . block as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( md2_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md2_ctx > ( ) ) ) . index as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( md2_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md2_init" ] pub fn nettle_md2_init ( ctx : * mut md2_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md2_update" ] pub fn nettle_md2_update ( ctx : * mut md2_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md2_digest" ] pub fn nettle_md2_digest ( ctx : * mut md2_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct md4_ctx { pub state : [ u32 ; 4usize ] , pub count : u64 , pub block : [ u8 ; 64usize ] , pub index : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_md4_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < md4_ctx > ( ) , 96usize , concat ! ( "Size of: " , stringify ! ( md4_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < md4_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( md4_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md4_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( md4_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md4_ctx > ( ) ) ) . count as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( md4_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md4_ctx > ( ) ) ) . block as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( md4_ctx ) , "::" , stringify ! ( block ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < md4_ctx > ( ) ) ) . index as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( md4_ctx ) , "::" , stringify ! ( index ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md4_init" ] pub fn nettle_md4_init ( ctx : * mut md4_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md4_update" ] pub fn nettle_md4_update ( ctx : * mut md4_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_md4_digest" ] pub fn nettle_md4_digest ( ctx : * mut md4_ctx , length : usize , digest : * mut u8 ) ; } pub type MD5_CTX = md5_ctx ; extern "C" { # [ link_name = "\u{1}_nettle_MD5Init" ] pub fn nettle_MD5Init ( ctx : * mut MD5_CTX ) ; } extern "C" { # [ link_name = "\u{1}_nettle_MD5Update" ] pub fn nettle_MD5Update ( ctx : * mut MD5_CTX , data : * const :: std :: os :: raw :: c_uchar , length : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_nettle_MD5Final" ] pub fn nettle_MD5Final ( out : * mut :: std :: os :: raw :: c_uchar , ctx : * mut MD5_CTX ) ; } pub type __darwin_nl_item = :: std :: os :: raw :: c_int ; pub type __darwin_wctrans_t = :: std :: os :: raw :: c_int ; pub type __darwin_wctype_t = __uint32_t ; pub const idtype_t_P_ALL : idtype_t = 0 ; pub const idtype_t_P_PID : idtype_t = 1 ; pub const idtype_t_P_PGID : idtype_t = 2 ; pub type idtype_t = u32 ; pub type pid_t = __darwin_pid_t ; pub type id_t = __darwin_id_t ; pub type sig_atomic_t = :: std :: os :: raw :: c_int ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_i386_thread_state { pub __eax : :: std :: os :: raw :: c_uint , pub __ebx : :: std :: os :: raw :: c_uint , pub __ecx : :: std :: os :: raw :: c_uint , pub __edx : :: std :: os :: raw :: c_uint , pub __edi : :: std :: os :: raw :: c_uint , pub __esi : :: std :: os :: raw :: c_uint , pub __ebp : :: std :: os :: raw :: c_uint , pub __esp : :: std :: os :: raw :: c_uint , pub __ss : :: std :: os :: raw :: c_uint , pub __eflags : :: std :: os :: raw :: c_uint , pub __eip : :: std :: os :: raw :: c_uint , pub __cs : :: std :: os :: raw :: c_uint , pub __ds : :: std :: os :: raw :: c_uint , pub __es : :: std :: os :: raw :: c_uint , pub __fs : :: std :: os :: raw :: c_uint , pub __gs : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout___darwin_i386_thread_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_i386_thread_state > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( __darwin_i386_thread_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_i386_thread_state > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_i386_thread_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __eax as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __eax ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __ebx as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __ebx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __ecx as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __ecx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __edx as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __edx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __edi as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __edi ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __esi as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __esi ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __ebp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __ebp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __esp as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __esp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __ss as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __eflags as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __eflags ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __eip as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __eip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __cs as * const _ as usize } , 44usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __ds as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __es as * const _ as usize } , 52usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __fs as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __fs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_thread_state > ( ) ) ) . __gs as * const _ as usize } , 60usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_thread_state ) , "::" , stringify ! ( __gs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_fp_control { pub _bitfield_1 : __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > , pub __bindgen_align : [ u16 ; 0usize ] , } # [ test ] fn bindgen_test_layout___darwin_fp_control ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_fp_control > ( ) , 2usize , concat ! ( "Size of: " , stringify ! ( __darwin_fp_control ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_fp_control > ( ) , 2usize , concat ! ( "Alignment of " , stringify ! ( __darwin_fp_control ) ) ) ; } impl __darwin_fp_control { # [ inline ] pub fn __invalid ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 0usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___invalid ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 0usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __denorm ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 1usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___denorm ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 1usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __zdiv ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 2usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___zdiv ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 2usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __ovrfl ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 3usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___ovrfl ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 3usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __undfl ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 4usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___undfl ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 4usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __precis ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 5usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___precis ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 5usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __pc ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 8usize , 2u8 ) as u16 ) } } # [ inline ] pub fn set___pc ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 8usize , 2u8 , val as u64 ) } } # [ inline ] pub fn __rc ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 10usize , 2u8 ) as u16 ) } } # [ inline ] pub fn set___rc ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 10usize , 2u8 , val as u64 ) } } # [ inline ] pub fn new_bitfield_1 ( __invalid : :: std :: os :: raw :: c_ushort , __denorm : :: std :: os :: raw :: c_ushort , __zdiv : :: std :: os :: raw :: c_ushort , __ovrfl : :: std :: os :: raw :: c_ushort , __undfl : :: std :: os :: raw :: c_ushort , __precis : :: std :: os :: raw :: c_ushort , __pc : :: std :: os :: raw :: c_ushort , __rc : :: std :: os :: raw :: c_ushort ) -> __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > = Default :: default ( ) ; __bindgen_bitfield_unit . set ( 0usize , 1u8 , { let __invalid : u16 = unsafe { :: std :: mem :: transmute ( __invalid ) } ; __invalid as u64 } ) ; __bindgen_bitfield_unit . set ( 1usize , 1u8 , { let __denorm : u16 = unsafe { :: std :: mem :: transmute ( __denorm ) } ; __denorm as u64 } ) ; __bindgen_bitfield_unit . set ( 2usize , 1u8 , { let __zdiv : u16 = unsafe { :: std :: mem :: transmute ( __zdiv ) } ; __zdiv as u64 } ) ; __bindgen_bitfield_unit . set ( 3usize , 1u8 , { let __ovrfl : u16 = unsafe { :: std :: mem :: transmute ( __ovrfl ) } ; __ovrfl as u64 } ) ; __bindgen_bitfield_unit . set ( 4usize , 1u8 , { let __undfl : u16 = unsafe { :: std :: mem :: transmute ( __undfl ) } ; __undfl as u64 } ) ; __bindgen_bitfield_unit . set ( 5usize , 1u8 , { let __precis : u16 = unsafe { :: std :: mem :: transmute ( __precis ) } ; __precis as u64 } ) ; __bindgen_bitfield_unit . set ( 8usize , 2u8 , { let __pc : u16 = unsafe { :: std :: mem :: transmute ( __pc ) } ; __pc as u64 } ) ; __bindgen_bitfield_unit . set ( 10usize , 2u8 , { let __rc : u16 = unsafe { :: std :: mem :: transmute ( __rc ) } ; __rc as u64 } ) ; __bindgen_bitfield_unit } } pub type __darwin_fp_control_t = __darwin_fp_control ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_fp_status { pub _bitfield_1 : __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > , pub __bindgen_align : [ u16 ; 0usize ] , } # [ test ] fn bindgen_test_layout___darwin_fp_status ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_fp_status > ( ) , 2usize , concat ! ( "Size of: " , stringify ! ( __darwin_fp_status ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_fp_status > ( ) , 2usize , concat ! ( "Alignment of " , stringify ! ( __darwin_fp_status ) ) ) ; } impl __darwin_fp_status { # [ inline ] pub fn __invalid ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 0usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___invalid ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 0usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __denorm ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 1usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___denorm ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 1usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __zdiv ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 2usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___zdiv ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 2usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __ovrfl ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 3usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___ovrfl ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 3usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __undfl ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 4usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___undfl ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 4usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __precis ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 5usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___precis ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 5usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __stkflt ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 6usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___stkflt ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 6usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __errsumm ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 7usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___errsumm ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 7usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __c0 ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 8usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___c0 ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 8usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __c1 ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 9usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___c1 ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 9usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __c2 ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 10usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___c2 ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 10usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __tos ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 11usize , 3u8 ) as u16 ) } } # [ inline ] pub fn set___tos ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 11usize , 3u8 , val as u64 ) } } # [ inline ] pub fn __c3 ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 14usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___c3 ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 14usize , 1u8 , val as u64 ) } } # [ inline ] pub fn __busy ( & self ) -> :: std :: os :: raw :: c_ushort { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 15usize , 1u8 ) as u16 ) } } # [ inline ] pub fn set___busy ( & mut self , val : :: std :: os :: raw :: c_ushort ) { unsafe { let val : u16 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 15usize , 1u8 , val as u64 ) } } # [ inline ] pub fn new_bitfield_1 ( __invalid : :: std :: os :: raw :: c_ushort , __denorm : :: std :: os :: raw :: c_ushort , __zdiv : :: std :: os :: raw :: c_ushort , __ovrfl : :: std :: os :: raw :: c_ushort , __undfl : :: std :: os :: raw :: c_ushort , __precis : :: std :: os :: raw :: c_ushort , __stkflt : :: std :: os :: raw :: c_ushort , __errsumm : :: std :: os :: raw :: c_ushort , __c0 : :: std :: os :: raw :: c_ushort , __c1 : :: std :: os :: raw :: c_ushort , __c2 : :: std :: os :: raw :: c_ushort , __tos : :: std :: os :: raw :: c_ushort , __c3 : :: std :: os :: raw :: c_ushort , __busy : :: std :: os :: raw :: c_ushort ) -> __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [ u8 ; 2usize ] , u8 > = Default :: default ( ) ; __bindgen_bitfield_unit . set ( 0usize , 1u8 , { let __invalid : u16 = unsafe { :: std :: mem :: transmute ( __invalid ) } ; __invalid as u64 } ) ; __bindgen_bitfield_unit . set ( 1usize , 1u8 , { let __denorm : u16 = unsafe { :: std :: mem :: transmute ( __denorm ) } ; __denorm as u64 } ) ; __bindgen_bitfield_unit . set ( 2usize , 1u8 , { let __zdiv : u16 = unsafe { :: std :: mem :: transmute ( __zdiv ) } ; __zdiv as u64 } ) ; __bindgen_bitfield_unit . set ( 3usize , 1u8 , { let __ovrfl : u16 = unsafe { :: std :: mem :: transmute ( __ovrfl ) } ; __ovrfl as u64 } ) ; __bindgen_bitfield_unit . set ( 4usize , 1u8 , { let __undfl : u16 = unsafe { :: std :: mem :: transmute ( __undfl ) } ; __undfl as u64 } ) ; __bindgen_bitfield_unit . set ( 5usize , 1u8 , { let __precis : u16 = unsafe { :: std :: mem :: transmute ( __precis ) } ; __precis as u64 } ) ; __bindgen_bitfield_unit . set ( 6usize , 1u8 , { let __stkflt : u16 = unsafe { :: std :: mem :: transmute ( __stkflt ) } ; __stkflt as u64 } ) ; __bindgen_bitfield_unit . set ( 7usize , 1u8 , { let __errsumm : u16 = unsafe { :: std :: mem :: transmute ( __errsumm ) } ; __errsumm as u64 } ) ; __bindgen_bitfield_unit . set ( 8usize , 1u8 , { let __c0 : u16 = unsafe { :: std :: mem :: transmute ( __c0 ) } ; __c0 as u64 } ) ; __bindgen_bitfield_unit . set ( 9usize , 1u8 , { let __c1 : u16 = unsafe { :: std :: mem :: transmute ( __c1 ) } ; __c1 as u64 } ) ; __bindgen_bitfield_unit . set ( 10usize , 1u8 , { let __c2 : u16 = unsafe { :: std :: mem :: transmute ( __c2 ) } ; __c2 as u64 } ) ; __bindgen_bitfield_unit . set ( 11usize , 3u8 , { let __tos : u16 = unsafe { :: std :: mem :: transmute ( __tos ) } ; __tos as u64 } ) ; __bindgen_bitfield_unit . set ( 14usize , 1u8 , { let __c3 : u16 = unsafe { :: std :: mem :: transmute ( __c3 ) } ; __c3 as u64 } ) ; __bindgen_bitfield_unit . set ( 15usize , 1u8 , { let __busy : u16 = unsafe { :: std :: mem :: transmute ( __busy ) } ; __busy as u64 } ) ; __bindgen_bitfield_unit } } pub type __darwin_fp_status_t = __darwin_fp_status ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_mmst_reg { pub __mmst_reg : [ :: std :: os :: raw :: c_char ; 10usize ] , pub __mmst_rsrv : [ :: std :: os :: raw :: c_char ; 6usize ] , } # [ test ] fn bindgen_test_layout___darwin_mmst_reg ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mmst_reg > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( __darwin_mmst_reg ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mmst_reg > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mmst_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mmst_reg > ( ) ) ) . __mmst_reg as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mmst_reg ) , "::" , stringify ! ( __mmst_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mmst_reg > ( ) ) ) . __mmst_rsrv as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mmst_reg ) , "::" , stringify ! ( __mmst_rsrv ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_xmm_reg { pub __xmm_reg : [ :: std :: os :: raw :: c_char ; 16usize ] , } # [ test ] fn bindgen_test_layout___darwin_xmm_reg ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_xmm_reg > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( __darwin_xmm_reg ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_xmm_reg > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( __darwin_xmm_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_xmm_reg > ( ) ) ) . __xmm_reg as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_xmm_reg ) , "::" , stringify ! ( __xmm_reg ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_ymm_reg { pub __ymm_reg : [ :: std :: os :: raw :: c_char ; 32usize ] , } # [ test ] fn bindgen_test_layout___darwin_ymm_reg ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_ymm_reg > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( __darwin_ymm_reg ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_ymm_reg > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( __darwin_ymm_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ymm_reg > ( ) ) ) . __ymm_reg as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ymm_reg ) , "::" , stringify ! ( __ymm_reg ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_zmm_reg { pub __zmm_reg : [ :: std :: os :: raw :: c_char ; 64usize ] , } # [ test ] fn bindgen_test_layout___darwin_zmm_reg ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_zmm_reg > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( __darwin_zmm_reg ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_zmm_reg > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( __darwin_zmm_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_zmm_reg > ( ) ) ) . __zmm_reg as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_zmm_reg ) , "::" , stringify ! ( __zmm_reg ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_opmask_reg { pub __opmask_reg : [ :: std :: os :: raw :: c_char ; 8usize ] , } # [ test ] fn bindgen_test_layout___darwin_opmask_reg ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_opmask_reg > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( __darwin_opmask_reg ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_opmask_reg > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( __darwin_opmask_reg ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_opmask_reg > ( ) ) ) . __opmask_reg as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_opmask_reg ) , "::" , stringify ! ( __opmask_reg ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_i386_float_state { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 224usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout___darwin_i386_float_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_i386_float_state > ( ) , 524usize , concat ! ( "Size of: " , stringify ! ( __darwin_i386_float_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_i386_float_state > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_i386_float_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_float_state > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_float_state ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_i386_avx_state { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 224usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , pub __avx_reserved1 : [ :: std :: os :: raw :: c_char ; 64usize ] , pub __fpu_ymmh0 : __darwin_xmm_reg , pub __fpu_ymmh1 : __darwin_xmm_reg , pub __fpu_ymmh2 : __darwin_xmm_reg , pub __fpu_ymmh3 : __darwin_xmm_reg , pub __fpu_ymmh4 : __darwin_xmm_reg , pub __fpu_ymmh5 : __darwin_xmm_reg , pub __fpu_ymmh6 : __darwin_xmm_reg , pub __fpu_ymmh7 : __darwin_xmm_reg , } # [ test ] fn bindgen_test_layout___darwin_i386_avx_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_i386_avx_state > ( ) , 716usize , concat ! ( "Size of: " , stringify ! ( __darwin_i386_avx_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_i386_avx_state > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_i386_avx_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __avx_reserved1 as * const _ as usize } , 524usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __avx_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh0 as * const _ as usize } , 588usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh1 as * const _ as usize } , 604usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh2 as * const _ as usize } , 620usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh3 as * const _ as usize } , 636usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh4 as * const _ as usize } , 652usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh5 as * const _ as usize } , 668usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh6 as * const _ as usize } , 684usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx_state > ( ) ) ) . __fpu_ymmh7 as * const _ as usize } , 700usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx_state ) , "::" , stringify ! ( __fpu_ymmh7 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_i386_avx512_state { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 224usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , pub __avx_reserved1 : [ :: std :: os :: raw :: c_char ; 64usize ] , pub __fpu_ymmh0 : __darwin_xmm_reg , pub __fpu_ymmh1 : __darwin_xmm_reg , pub __fpu_ymmh2 : __darwin_xmm_reg , pub __fpu_ymmh3 : __darwin_xmm_reg , pub __fpu_ymmh4 : __darwin_xmm_reg , pub __fpu_ymmh5 : __darwin_xmm_reg , pub __fpu_ymmh6 : __darwin_xmm_reg , pub __fpu_ymmh7 : __darwin_xmm_reg , pub __fpu_k0 : __darwin_opmask_reg , pub __fpu_k1 : __darwin_opmask_reg , pub __fpu_k2 : __darwin_opmask_reg , pub __fpu_k3 : __darwin_opmask_reg , pub __fpu_k4 : __darwin_opmask_reg , pub __fpu_k5 : __darwin_opmask_reg , pub __fpu_k6 : __darwin_opmask_reg , pub __fpu_k7 : __darwin_opmask_reg , pub __fpu_zmmh0 : __darwin_ymm_reg , pub __fpu_zmmh1 : __darwin_ymm_reg , pub __fpu_zmmh2 : __darwin_ymm_reg , pub __fpu_zmmh3 : __darwin_ymm_reg , pub __fpu_zmmh4 : __darwin_ymm_reg , pub __fpu_zmmh5 : __darwin_ymm_reg , pub __fpu_zmmh6 : __darwin_ymm_reg , pub __fpu_zmmh7 : __darwin_ymm_reg , } # [ test ] fn bindgen_test_layout___darwin_i386_avx512_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_i386_avx512_state > ( ) , 1036usize , concat ! ( "Size of: " , stringify ! ( __darwin_i386_avx512_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_i386_avx512_state > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_i386_avx512_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __avx_reserved1 as * const _ as usize } , 524usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __avx_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh0 as * const _ as usize } , 588usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh1 as * const _ as usize } , 604usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh2 as * const _ as usize } , 620usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh3 as * const _ as usize } , 636usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh4 as * const _ as usize } , 652usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh5 as * const _ as usize } , 668usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh6 as * const _ as usize } , 684usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_ymmh7 as * const _ as usize } , 700usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_ymmh7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k0 as * const _ as usize } , 716usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k1 as * const _ as usize } , 724usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k2 as * const _ as usize } , 732usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k3 as * const _ as usize } , 740usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k4 as * const _ as usize } , 748usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k5 as * const _ as usize } , 756usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k6 as * const _ as usize } , 764usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_k7 as * const _ as usize } , 772usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_k7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh0 as * const _ as usize } , 780usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh1 as * const _ as usize } , 812usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh2 as * const _ as usize } , 844usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh3 as * const _ as usize } , 876usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh4 as * const _ as usize } , 908usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh5 as * const _ as usize } , 940usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh6 as * const _ as usize } , 972usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_avx512_state > ( ) ) ) . __fpu_zmmh7 as * const _ as usize } , 1004usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_avx512_state ) , "::" , stringify ! ( __fpu_zmmh7 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_i386_exception_state { pub __trapno : __uint16_t , pub __cpu : __uint16_t , pub __err : __uint32_t , pub __faultvaddr : __uint32_t , } # [ test ] fn bindgen_test_layout___darwin_i386_exception_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_i386_exception_state > ( ) , 12usize , concat ! ( "Size of: " , stringify ! ( __darwin_i386_exception_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_i386_exception_state > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_i386_exception_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_exception_state > ( ) ) ) . __trapno as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_exception_state ) , "::" , stringify ! ( __trapno ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_exception_state > ( ) ) ) . __cpu as * const _ as usize } , 2usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_exception_state ) , "::" , stringify ! ( __cpu ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_exception_state > ( ) ) ) . __err as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_exception_state ) , "::" , stringify ! ( __err ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_i386_exception_state > ( ) ) ) . __faultvaddr as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_i386_exception_state ) , "::" , stringify ! ( __faultvaddr ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_debug_state32 { pub __dr0 : :: std :: os :: raw :: c_uint , pub __dr1 : :: std :: os :: raw :: c_uint , pub __dr2 : :: std :: os :: raw :: c_uint , pub __dr3 : :: std :: os :: raw :: c_uint , pub __dr4 : :: std :: os :: raw :: c_uint , pub __dr5 : :: std :: os :: raw :: c_uint , pub __dr6 : :: std :: os :: raw :: c_uint , pub __dr7 : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout___darwin_x86_debug_state32 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_debug_state32 > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_debug_state32 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_debug_state32 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_debug_state32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr0 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr1 as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr2 as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr3 as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr4 as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr5 as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr6 as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state32 > ( ) ) ) . __dr7 as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state32 ) , "::" , stringify ! ( __dr7 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_thread_state64 { pub __rax : __uint64_t , pub __rbx : __uint64_t , pub __rcx : __uint64_t , pub __rdx : __uint64_t , pub __rdi : __uint64_t , pub __rsi : __uint64_t , pub __rbp : __uint64_t , pub __rsp : __uint64_t , pub __r8 : __uint64_t , pub __r9 : __uint64_t , pub __r10 : __uint64_t , pub __r11 : __uint64_t , pub __r12 : __uint64_t , pub __r13 : __uint64_t , pub __r14 : __uint64_t , pub __r15 : __uint64_t , pub __rip : __uint64_t , pub __rflags : __uint64_t , pub __cs : __uint64_t , pub __fs : __uint64_t , pub __gs : __uint64_t , } # [ test ] fn bindgen_test_layout___darwin_x86_thread_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_thread_state64 > ( ) , 168usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_thread_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_thread_state64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_thread_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rax as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rax ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rbx as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rbx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rcx as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rcx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rdx as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rdx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rdi as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rdi ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rsi as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rsi ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rbp as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rbp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rsp as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rsp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r8 as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r9 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r10 as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r11 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r12 as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r13 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r14 as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __r15 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __r15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rip as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __rflags as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __rflags ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __cs as * const _ as usize } , 144usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __fs as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __fs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_state64 > ( ) ) ) . __gs as * const _ as usize } , 160usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_state64 ) , "::" , stringify ! ( __gs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_thread_full_state64 { pub ss64 : __darwin_x86_thread_state64 , pub __ds : __uint64_t , pub __es : __uint64_t , pub __ss : __uint64_t , } # [ test ] fn bindgen_test_layout___darwin_x86_thread_full_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_thread_full_state64 > ( ) , 192usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_thread_full_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_thread_full_state64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_thread_full_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_full_state64 > ( ) ) ) . ss64 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_full_state64 ) , "::" , stringify ! ( ss64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_full_state64 > ( ) ) ) . __ds as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_full_state64 ) , "::" , stringify ! ( __ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_full_state64 > ( ) ) ) . __es as * const _ as usize } , 176usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_full_state64 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_thread_full_state64 > ( ) ) ) . __ss as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_thread_full_state64 ) , "::" , stringify ! ( __ss ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_x86_float_state64 { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_xmm8 : __darwin_xmm_reg , pub __fpu_xmm9 : __darwin_xmm_reg , pub __fpu_xmm10 : __darwin_xmm_reg , pub __fpu_xmm11 : __darwin_xmm_reg , pub __fpu_xmm12 : __darwin_xmm_reg , pub __fpu_xmm13 : __darwin_xmm_reg , pub __fpu_xmm14 : __darwin_xmm_reg , pub __fpu_xmm15 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 96usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout___darwin_x86_float_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_float_state64 > ( ) , 524usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_float_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_float_state64 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_float_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm8 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm9 as * const _ as usize } , 312usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm10 as * const _ as usize } , 328usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm11 as * const _ as usize } , 344usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm12 as * const _ as usize } , 360usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm13 as * const _ as usize } , 376usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm14 as * const _ as usize } , 392usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_xmm15 as * const _ as usize } , 408usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_xmm15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 424usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_float_state64 > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_float_state64 ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_x86_avx_state64 { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_xmm8 : __darwin_xmm_reg , pub __fpu_xmm9 : __darwin_xmm_reg , pub __fpu_xmm10 : __darwin_xmm_reg , pub __fpu_xmm11 : __darwin_xmm_reg , pub __fpu_xmm12 : __darwin_xmm_reg , pub __fpu_xmm13 : __darwin_xmm_reg , pub __fpu_xmm14 : __darwin_xmm_reg , pub __fpu_xmm15 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 96usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , pub __avx_reserved1 : [ :: std :: os :: raw :: c_char ; 64usize ] , pub __fpu_ymmh0 : __darwin_xmm_reg , pub __fpu_ymmh1 : __darwin_xmm_reg , pub __fpu_ymmh2 : __darwin_xmm_reg , pub __fpu_ymmh3 : __darwin_xmm_reg , pub __fpu_ymmh4 : __darwin_xmm_reg , pub __fpu_ymmh5 : __darwin_xmm_reg , pub __fpu_ymmh6 : __darwin_xmm_reg , pub __fpu_ymmh7 : __darwin_xmm_reg , pub __fpu_ymmh8 : __darwin_xmm_reg , pub __fpu_ymmh9 : __darwin_xmm_reg , pub __fpu_ymmh10 : __darwin_xmm_reg , pub __fpu_ymmh11 : __darwin_xmm_reg , pub __fpu_ymmh12 : __darwin_xmm_reg , pub __fpu_ymmh13 : __darwin_xmm_reg , pub __fpu_ymmh14 : __darwin_xmm_reg , pub __fpu_ymmh15 : __darwin_xmm_reg , } # [ test ] fn bindgen_test_layout___darwin_x86_avx_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_avx_state64 > ( ) , 844usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_avx_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_avx_state64 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_avx_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm8 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm9 as * const _ as usize } , 312usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm10 as * const _ as usize } , 328usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm11 as * const _ as usize } , 344usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm12 as * const _ as usize } , 360usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm13 as * const _ as usize } , 376usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm14 as * const _ as usize } , 392usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_xmm15 as * const _ as usize } , 408usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_xmm15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 424usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __avx_reserved1 as * const _ as usize } , 524usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __avx_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh0 as * const _ as usize } , 588usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh1 as * const _ as usize } , 604usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh2 as * const _ as usize } , 620usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh3 as * const _ as usize } , 636usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh4 as * const _ as usize } , 652usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh5 as * const _ as usize } , 668usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh6 as * const _ as usize } , 684usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh7 as * const _ as usize } , 700usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh8 as * const _ as usize } , 716usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh9 as * const _ as usize } , 732usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh10 as * const _ as usize } , 748usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh11 as * const _ as usize } , 764usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh12 as * const _ as usize } , 780usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh13 as * const _ as usize } , 796usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh14 as * const _ as usize } , 812usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx_state64 > ( ) ) ) . __fpu_ymmh15 as * const _ as usize } , 828usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx_state64 ) , "::" , stringify ! ( __fpu_ymmh15 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_x86_avx512_state64 { pub __fpu_reserved : [ :: std :: os :: raw :: c_int ; 2usize ] , pub __fpu_fcw : __darwin_fp_control , pub __fpu_fsw : __darwin_fp_status , pub __fpu_ftw : __uint8_t , pub __fpu_rsrv1 : __uint8_t , pub __fpu_fop : __uint16_t , pub __fpu_ip : __uint32_t , pub __fpu_cs : __uint16_t , pub __fpu_rsrv2 : __uint16_t , pub __fpu_dp : __uint32_t , pub __fpu_ds : __uint16_t , pub __fpu_rsrv3 : __uint16_t , pub __fpu_mxcsr : __uint32_t , pub __fpu_mxcsrmask : __uint32_t , pub __fpu_stmm0 : __darwin_mmst_reg , pub __fpu_stmm1 : __darwin_mmst_reg , pub __fpu_stmm2 : __darwin_mmst_reg , pub __fpu_stmm3 : __darwin_mmst_reg , pub __fpu_stmm4 : __darwin_mmst_reg , pub __fpu_stmm5 : __darwin_mmst_reg , pub __fpu_stmm6 : __darwin_mmst_reg , pub __fpu_stmm7 : __darwin_mmst_reg , pub __fpu_xmm0 : __darwin_xmm_reg , pub __fpu_xmm1 : __darwin_xmm_reg , pub __fpu_xmm2 : __darwin_xmm_reg , pub __fpu_xmm3 : __darwin_xmm_reg , pub __fpu_xmm4 : __darwin_xmm_reg , pub __fpu_xmm5 : __darwin_xmm_reg , pub __fpu_xmm6 : __darwin_xmm_reg , pub __fpu_xmm7 : __darwin_xmm_reg , pub __fpu_xmm8 : __darwin_xmm_reg , pub __fpu_xmm9 : __darwin_xmm_reg , pub __fpu_xmm10 : __darwin_xmm_reg , pub __fpu_xmm11 : __darwin_xmm_reg , pub __fpu_xmm12 : __darwin_xmm_reg , pub __fpu_xmm13 : __darwin_xmm_reg , pub __fpu_xmm14 : __darwin_xmm_reg , pub __fpu_xmm15 : __darwin_xmm_reg , pub __fpu_rsrv4 : [ :: std :: os :: raw :: c_char ; 96usize ] , pub __fpu_reserved1 : :: std :: os :: raw :: c_int , pub __avx_reserved1 : [ :: std :: os :: raw :: c_char ; 64usize ] , pub __fpu_ymmh0 : __darwin_xmm_reg , pub __fpu_ymmh1 : __darwin_xmm_reg , pub __fpu_ymmh2 : __darwin_xmm_reg , pub __fpu_ymmh3 : __darwin_xmm_reg , pub __fpu_ymmh4 : __darwin_xmm_reg , pub __fpu_ymmh5 : __darwin_xmm_reg , pub __fpu_ymmh6 : __darwin_xmm_reg , pub __fpu_ymmh7 : __darwin_xmm_reg , pub __fpu_ymmh8 : __darwin_xmm_reg , pub __fpu_ymmh9 : __darwin_xmm_reg , pub __fpu_ymmh10 : __darwin_xmm_reg , pub __fpu_ymmh11 : __darwin_xmm_reg , pub __fpu_ymmh12 : __darwin_xmm_reg , pub __fpu_ymmh13 : __darwin_xmm_reg , pub __fpu_ymmh14 : __darwin_xmm_reg , pub __fpu_ymmh15 : __darwin_xmm_reg , pub __fpu_k0 : __darwin_opmask_reg , pub __fpu_k1 : __darwin_opmask_reg , pub __fpu_k2 : __darwin_opmask_reg , pub __fpu_k3 : __darwin_opmask_reg , pub __fpu_k4 : __darwin_opmask_reg , pub __fpu_k5 : __darwin_opmask_reg , pub __fpu_k6 : __darwin_opmask_reg , pub __fpu_k7 : __darwin_opmask_reg , pub __fpu_zmmh0 : __darwin_ymm_reg , pub __fpu_zmmh1 : __darwin_ymm_reg , pub __fpu_zmmh2 : __darwin_ymm_reg , pub __fpu_zmmh3 : __darwin_ymm_reg , pub __fpu_zmmh4 : __darwin_ymm_reg , pub __fpu_zmmh5 : __darwin_ymm_reg , pub __fpu_zmmh6 : __darwin_ymm_reg , pub __fpu_zmmh7 : __darwin_ymm_reg , pub __fpu_zmmh8 : __darwin_ymm_reg , pub __fpu_zmmh9 : __darwin_ymm_reg , pub __fpu_zmmh10 : __darwin_ymm_reg , pub __fpu_zmmh11 : __darwin_ymm_reg , pub __fpu_zmmh12 : __darwin_ymm_reg , pub __fpu_zmmh13 : __darwin_ymm_reg , pub __fpu_zmmh14 : __darwin_ymm_reg , pub __fpu_zmmh15 : __darwin_ymm_reg , pub __fpu_zmm16 : __darwin_zmm_reg , pub __fpu_zmm17 : __darwin_zmm_reg , pub __fpu_zmm18 : __darwin_zmm_reg , pub __fpu_zmm19 : __darwin_zmm_reg , pub __fpu_zmm20 : __darwin_zmm_reg , pub __fpu_zmm21 : __darwin_zmm_reg , pub __fpu_zmm22 : __darwin_zmm_reg , pub __fpu_zmm23 : __darwin_zmm_reg , pub __fpu_zmm24 : __darwin_zmm_reg , pub __fpu_zmm25 : __darwin_zmm_reg , pub __fpu_zmm26 : __darwin_zmm_reg , pub __fpu_zmm27 : __darwin_zmm_reg , pub __fpu_zmm28 : __darwin_zmm_reg , pub __fpu_zmm29 : __darwin_zmm_reg , pub __fpu_zmm30 : __darwin_zmm_reg , pub __fpu_zmm31 : __darwin_zmm_reg , } # [ test ] fn bindgen_test_layout___darwin_x86_avx512_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_avx512_state64 > ( ) , 2444usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_avx512_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_avx512_state64 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_avx512_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_reserved as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_reserved ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_fcw as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_fcw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_fsw as * const _ as usize } , 10usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_fsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ftw as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ftw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_rsrv1 as * const _ as usize } , 13usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_rsrv1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_fop as * const _ as usize } , 14usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_fop ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ip as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ip ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_cs as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_cs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_rsrv2 as * const _ as usize } , 22usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_rsrv2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_dp as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_dp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ds as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ds ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_rsrv3 as * const _ as usize } , 30usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_rsrv3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_mxcsr as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_mxcsr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_mxcsrmask as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_mxcsrmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm0 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm1 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm2 as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm3 as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm4 as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm5 as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm6 as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_stmm7 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_stmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm0 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm1 as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm2 as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm3 as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm4 as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm5 as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm6 as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm7 as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm8 as * const _ as usize } , 296usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm9 as * const _ as usize } , 312usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm10 as * const _ as usize } , 328usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm11 as * const _ as usize } , 344usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm12 as * const _ as usize } , 360usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm13 as * const _ as usize } , 376usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm14 as * const _ as usize } , 392usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_xmm15 as * const _ as usize } , 408usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_xmm15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_rsrv4 as * const _ as usize } , 424usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_rsrv4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_reserved1 as * const _ as usize } , 520usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __avx_reserved1 as * const _ as usize } , 524usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __avx_reserved1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh0 as * const _ as usize } , 588usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh1 as * const _ as usize } , 604usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh2 as * const _ as usize } , 620usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh3 as * const _ as usize } , 636usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh4 as * const _ as usize } , 652usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh5 as * const _ as usize } , 668usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh6 as * const _ as usize } , 684usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh7 as * const _ as usize } , 700usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh8 as * const _ as usize } , 716usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh9 as * const _ as usize } , 732usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh10 as * const _ as usize } , 748usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh11 as * const _ as usize } , 764usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh12 as * const _ as usize } , 780usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh13 as * const _ as usize } , 796usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh14 as * const _ as usize } , 812usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_ymmh15 as * const _ as usize } , 828usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_ymmh15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k0 as * const _ as usize } , 844usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k1 as * const _ as usize } , 852usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k2 as * const _ as usize } , 860usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k3 as * const _ as usize } , 868usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k4 as * const _ as usize } , 876usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k5 as * const _ as usize } , 884usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k6 as * const _ as usize } , 892usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_k7 as * const _ as usize } , 900usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_k7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh0 as * const _ as usize } , 908usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh1 as * const _ as usize } , 940usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh2 as * const _ as usize } , 972usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh3 as * const _ as usize } , 1004usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh4 as * const _ as usize } , 1036usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh5 as * const _ as usize } , 1068usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh6 as * const _ as usize } , 1100usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh7 as * const _ as usize } , 1132usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh7 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh8 as * const _ as usize } , 1164usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh8 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh9 as * const _ as usize } , 1196usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh9 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh10 as * const _ as usize } , 1228usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh10 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh11 as * const _ as usize } , 1260usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh11 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh12 as * const _ as usize } , 1292usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh12 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh13 as * const _ as usize } , 1324usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh13 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh14 as * const _ as usize } , 1356usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh14 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmmh15 as * const _ as usize } , 1388usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmmh15 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm16 as * const _ as usize } , 1420usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm16 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm17 as * const _ as usize } , 1484usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm17 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm18 as * const _ as usize } , 1548usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm18 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm19 as * const _ as usize } , 1612usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm19 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm20 as * const _ as usize } , 1676usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm20 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm21 as * const _ as usize } , 1740usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm21 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm22 as * const _ as usize } , 1804usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm22 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm23 as * const _ as usize } , 1868usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm23 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm24 as * const _ as usize } , 1932usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm24 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm25 as * const _ as usize } , 1996usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm25 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm26 as * const _ as usize } , 2060usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm26 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm27 as * const _ as usize } , 2124usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm27 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm28 as * const _ as usize } , 2188usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm28 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm29 as * const _ as usize } , 2252usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm29 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm30 as * const _ as usize } , 2316usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm30 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_avx512_state64 > ( ) ) ) . __fpu_zmm31 as * const _ as usize } , 2380usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_avx512_state64 ) , "::" , stringify ! ( __fpu_zmm31 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_exception_state64 { pub __trapno : __uint16_t , pub __cpu : __uint16_t , pub __err : __uint32_t , pub __faultvaddr : __uint64_t , } # [ test ] fn bindgen_test_layout___darwin_x86_exception_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_exception_state64 > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_exception_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_exception_state64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_exception_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_exception_state64 > ( ) ) ) . __trapno as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_exception_state64 ) , "::" , stringify ! ( __trapno ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_exception_state64 > ( ) ) ) . __cpu as * const _ as usize } , 2usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_exception_state64 ) , "::" , stringify ! ( __cpu ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_exception_state64 > ( ) ) ) . __err as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_exception_state64 ) , "::" , stringify ! ( __err ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_exception_state64 > ( ) ) ) . __faultvaddr as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_exception_state64 ) , "::" , stringify ! ( __faultvaddr ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_debug_state64 { pub __dr0 : __uint64_t , pub __dr1 : __uint64_t , pub __dr2 : __uint64_t , pub __dr3 : __uint64_t , pub __dr4 : __uint64_t , pub __dr5 : __uint64_t , pub __dr6 : __uint64_t , pub __dr7 : __uint64_t , } # [ test ] fn bindgen_test_layout___darwin_x86_debug_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_debug_state64 > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_debug_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_debug_state64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_debug_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr0 as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr1 as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr2 as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr3 as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr4 as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr5 as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr5 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr6 as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr6 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_debug_state64 > ( ) ) ) . __dr7 as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_debug_state64 ) , "::" , stringify ! ( __dr7 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_x86_cpmu_state64 { pub __ctrs : [ __uint64_t ; 16usize ] , } # [ test ] fn bindgen_test_layout___darwin_x86_cpmu_state64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_x86_cpmu_state64 > ( ) , 128usize , concat ! ( "Size of: " , stringify ! ( __darwin_x86_cpmu_state64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_x86_cpmu_state64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_x86_cpmu_state64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_x86_cpmu_state64 > ( ) ) ) . __ctrs as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_x86_cpmu_state64 ) , "::" , stringify ! ( __ctrs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext32 { pub __es : __darwin_i386_exception_state , pub __ss : __darwin_i386_thread_state , pub __fs : __darwin_i386_float_state , } # [ test ] fn bindgen_test_layout___darwin_mcontext32 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext32 > ( ) , 600usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext32 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext32 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext32 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext32 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext32 > ( ) ) ) . __ss as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext32 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext32 > ( ) ) ) . __fs as * const _ as usize } , 76usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext32 ) , "::" , stringify ! ( __fs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext_avx32 { pub __es : __darwin_i386_exception_state , pub __ss : __darwin_i386_thread_state , pub __fs : __darwin_i386_avx_state , } # [ test ] fn bindgen_test_layout___darwin_mcontext_avx32 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext_avx32 > ( ) , 792usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext_avx32 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext_avx32 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext_avx32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx32 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx32 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx32 > ( ) ) ) . __ss as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx32 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx32 > ( ) ) ) . __fs as * const _ as usize } , 76usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx32 ) , "::" , stringify ! ( __fs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext_avx512_32 { pub __es : __darwin_i386_exception_state , pub __ss : __darwin_i386_thread_state , pub __fs : __darwin_i386_avx512_state , } # [ test ] fn bindgen_test_layout___darwin_mcontext_avx512_32 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext_avx512_32 > ( ) , 1112usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext_avx512_32 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext_avx512_32 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext_avx512_32 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_32 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_32 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_32 > ( ) ) ) . __ss as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_32 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_32 > ( ) ) ) . __fs as * const _ as usize } , 76usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_32 ) , "::" , stringify ! ( __fs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext64 { pub __es : __darwin_x86_exception_state64 , pub __ss : __darwin_x86_thread_state64 , pub __fs : __darwin_x86_float_state64 , } # [ test ] fn bindgen_test_layout___darwin_mcontext64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext64 > ( ) , 712usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext64 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext64 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext64 > ( ) ) ) . __ss as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext64 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext64 > ( ) ) ) . __fs as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext64 ) , "::" , stringify ! ( __fs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext_avx64 { pub __es : __darwin_x86_exception_state64 , pub __ss : __darwin_x86_thread_state64 , pub __fs : __darwin_x86_avx_state64 , } # [ test ] fn bindgen_test_layout___darwin_mcontext_avx64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext_avx64 > ( ) , 1032usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext_avx64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext_avx64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext_avx64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx64 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx64 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx64 > ( ) ) ) . __ss as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx64 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx64 > ( ) ) ) . __fs as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx64 ) , "::" , stringify ! ( __fs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __darwin_mcontext_avx512_64 { pub __es : __darwin_x86_exception_state64 , pub __ss : __darwin_x86_thread_state64 , pub __fs : __darwin_x86_avx512_state64 , } # [ test ] fn bindgen_test_layout___darwin_mcontext_avx512_64 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_mcontext_avx512_64 > ( ) , 2632usize , concat ! ( "Size of: " , stringify ! ( __darwin_mcontext_avx512_64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_mcontext_avx512_64 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_mcontext_avx512_64 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_64 > ( ) ) ) . __es as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_64 ) , "::" , stringify ! ( __es ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_64 > ( ) ) ) . __ss as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_64 ) , "::" , stringify ! ( __ss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_mcontext_avx512_64 > ( ) ) ) . __fs as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_mcontext_avx512_64 ) , "::" , stringify ! ( __fs ) ) ) ; } pub type mcontext_t = * mut __darwin_mcontext64 ; pub type pthread_attr_t = __darwin_pthread_attr_t ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_sigaltstack { pub ss_sp : * mut :: std :: os :: raw :: c_void , pub ss_size : __darwin_size_t , pub ss_flags : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout___darwin_sigaltstack ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_sigaltstack > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( __darwin_sigaltstack ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_sigaltstack > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_sigaltstack ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_sigaltstack > ( ) ) ) . ss_sp as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_sigaltstack ) , "::" , stringify ! ( ss_sp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_sigaltstack > ( ) ) ) . ss_size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_sigaltstack ) , "::" , stringify ! ( ss_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_sigaltstack > ( ) ) ) . ss_flags as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_sigaltstack ) , "::" , stringify ! ( ss_flags ) ) ) ; } pub type stack_t = __darwin_sigaltstack ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __darwin_ucontext { pub uc_onstack : :: std :: os :: raw :: c_int , pub uc_sigmask : __darwin_sigset_t , pub uc_stack : __darwin_sigaltstack , pub uc_link : * mut __darwin_ucontext , pub uc_mcsize : __darwin_size_t , pub uc_mcontext : * mut __darwin_mcontext64 , } # [ test ] fn bindgen_test_layout___darwin_ucontext ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __darwin_ucontext > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( __darwin_ucontext ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __darwin_ucontext > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __darwin_ucontext ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_onstack as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_onstack ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_sigmask as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_sigmask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_stack as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_stack ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_link as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_link ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_mcsize as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_mcsize ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __darwin_ucontext > ( ) ) ) . uc_mcontext as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( __darwin_ucontext ) , "::" , stringify ! ( uc_mcontext ) ) ) ; } pub type ucontext_t = __darwin_ucontext ; pub type sigset_t = __darwin_sigset_t ; pub type uid_t = __darwin_uid_t ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union sigval { pub sival_int : :: std :: os :: raw :: c_int , pub sival_ptr : * mut :: std :: os :: raw :: c_void , _bindgen_union_align : u64 , } # [ test ] fn bindgen_test_layout_sigval ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sigval > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( sigval ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sigval > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sigval ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigval > ( ) ) ) . sival_int as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigval ) , "::" , stringify ! ( sival_int ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigval > ( ) ) ) . sival_ptr as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigval ) , "::" , stringify ! ( sival_ptr ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sigevent { pub sigev_notify : :: std :: os :: raw :: c_int , pub sigev_signo : :: std :: os :: raw :: c_int , pub sigev_value : sigval , pub sigev_notify_function : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : sigval ) > , pub sigev_notify_attributes : * mut pthread_attr_t , } # [ test ] fn bindgen_test_layout_sigevent ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sigevent > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( sigevent ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sigevent > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sigevent ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigevent > ( ) ) ) . sigev_notify as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigevent ) , "::" , stringify ! ( sigev_notify ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigevent > ( ) ) ) . sigev_signo as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( sigevent ) , "::" , stringify ! ( sigev_signo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigevent > ( ) ) ) . sigev_value as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( sigevent ) , "::" , stringify ! ( sigev_value ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigevent > ( ) ) ) . sigev_notify_function as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( sigevent ) , "::" , stringify ! ( sigev_notify_function ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigevent > ( ) ) ) . sigev_notify_attributes as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( sigevent ) , "::" , stringify ! ( sigev_notify_attributes ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __siginfo { pub si_signo : :: std :: os :: raw :: c_int , pub si_errno : :: std :: os :: raw :: c_int , pub si_code : :: std :: os :: raw :: c_int , pub si_pid : pid_t , pub si_uid : uid_t , pub si_status : :: std :: os :: raw :: c_int , pub si_addr : * mut :: std :: os :: raw :: c_void , pub si_value : sigval , pub si_band : :: std :: os :: raw :: c_long , pub __pad : [ :: std :: os :: raw :: c_ulong ; 7usize ] , } # [ test ] fn bindgen_test_layout___siginfo ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __siginfo > ( ) , 104usize , concat ! ( "Size of: " , stringify ! ( __siginfo ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __siginfo > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __siginfo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_signo as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_signo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_errno as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_errno ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_code as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_code ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_pid as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_pid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_uid as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_uid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_status as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_status ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_addr as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_addr ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_value as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_value ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . si_band as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( si_band ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __siginfo > ( ) ) ) . __pad as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( __siginfo ) , "::" , stringify ! ( __pad ) ) ) ; } pub type siginfo_t = __siginfo ; # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union __sigaction_u { pub __sa_handler : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int ) > , pub __sa_sigaction : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int , arg2 : * mut __siginfo , arg3 : * mut :: std :: os :: raw :: c_void ) > , _bindgen_union_align : u64 , } # [ test ] fn bindgen_test_layout___sigaction_u ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __sigaction_u > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( __sigaction_u ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __sigaction_u > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __sigaction_u ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction_u > ( ) ) ) . __sa_handler as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction_u ) , "::" , stringify ! ( __sa_handler ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction_u > ( ) ) ) . __sa_sigaction as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction_u ) , "::" , stringify ! ( __sa_sigaction ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct __sigaction { pub __sigaction_u : __sigaction_u , pub sa_tramp : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : :: std :: os :: raw :: c_int , arg3 : :: std :: os :: raw :: c_int , arg4 : * mut siginfo_t , arg5 : * mut :: std :: os :: raw :: c_void ) > , pub sa_mask : sigset_t , pub sa_flags : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout___sigaction ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __sigaction > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( __sigaction ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __sigaction > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __sigaction ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction > ( ) ) ) . __sigaction_u as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction ) , "::" , stringify ! ( __sigaction_u ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction > ( ) ) ) . sa_tramp as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction ) , "::" , stringify ! ( sa_tramp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction > ( ) ) ) . sa_mask as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction ) , "::" , stringify ! ( sa_mask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __sigaction > ( ) ) ) . sa_flags as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( __sigaction ) , "::" , stringify ! ( sa_flags ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sigaction { pub __sigaction_u : __sigaction_u , pub sa_mask : sigset_t , pub sa_flags : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout_sigaction ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sigaction > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( sigaction ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sigaction > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sigaction ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigaction > ( ) ) ) . __sigaction_u as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigaction ) , "::" , stringify ! ( __sigaction_u ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigaction > ( ) ) ) . sa_mask as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( sigaction ) , "::" , stringify ! ( sa_mask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigaction > ( ) ) ) . sa_flags as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( sigaction ) , "::" , stringify ! ( sa_flags ) ) ) ; } pub type sig_t = :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int ) > ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct sigvec { pub sv_handler : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int ) > , pub sv_mask : :: std :: os :: raw :: c_int , pub sv_flags : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout_sigvec ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sigvec > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( sigvec ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sigvec > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sigvec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigvec > ( ) ) ) . sv_handler as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigvec ) , "::" , stringify ! ( sv_handler ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigvec > ( ) ) ) . sv_mask as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( sigvec ) , "::" , stringify ! ( sv_mask ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigvec > ( ) ) ) . sv_flags as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( sigvec ) , "::" , stringify ! ( sv_flags ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct sigstack { pub ss_sp : * mut :: std :: os :: raw :: c_char , pub ss_onstack : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout_sigstack ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sigstack > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( sigstack ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sigstack > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sigstack ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigstack > ( ) ) ) . ss_sp as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sigstack ) , "::" , stringify ! ( ss_sp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sigstack > ( ) ) ) . ss_onstack as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( sigstack ) , "::" , stringify ! ( ss_onstack ) ) ) ; } extern "C" { # [ link_name = "\u{1}_signal" ] pub fn signal ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int ) > ) -> :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : :: std :: os :: raw :: c_int ) > ) > ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct timeval { pub tv_sec : __darwin_time_t , pub tv_usec : __darwin_suseconds_t , } # [ test ] fn bindgen_test_layout_timeval ( ) { assert_eq ! ( :: std :: mem :: size_of :: < timeval > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( timeval ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < timeval > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( timeval ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < timeval > ( ) ) ) . tv_sec as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( timeval ) , "::" , stringify ! ( tv_sec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < timeval > ( ) ) ) . tv_usec as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( timeval ) , "::" , stringify ! ( tv_usec ) ) ) ; } pub type rlim_t = __uint64_t ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage { pub ru_utime : timeval , pub ru_stime : timeval , pub ru_maxrss : :: std :: os :: raw :: c_long , pub ru_ixrss : :: std :: os :: raw :: c_long , pub ru_idrss : :: std :: os :: raw :: c_long , pub ru_isrss : :: std :: os :: raw :: c_long , pub ru_minflt : :: std :: os :: raw :: c_long , pub ru_majflt : :: std :: os :: raw :: c_long , pub ru_nswap : :: std :: os :: raw :: c_long , pub ru_inblock : :: std :: os :: raw :: c_long , pub ru_oublock : :: std :: os :: raw :: c_long , pub ru_msgsnd : :: std :: os :: raw :: c_long , pub ru_msgrcv : :: std :: os :: raw :: c_long , pub ru_nsignals : :: std :: os :: raw :: c_long , pub ru_nvcsw : :: std :: os :: raw :: c_long , pub ru_nivcsw : :: std :: os :: raw :: c_long , } # [ test ] fn bindgen_test_layout_rusage ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage > ( ) , 144usize , concat ! ( "Size of: " , stringify ! ( rusage ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_utime as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_utime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_stime as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_stime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_maxrss as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_maxrss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_ixrss as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_ixrss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_idrss as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_idrss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_isrss as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_isrss ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_minflt as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_minflt ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_majflt as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_majflt ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_nswap as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_nswap ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_inblock as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_inblock ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_oublock as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_oublock ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_msgsnd as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_msgsnd ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_msgrcv as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_msgrcv ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_nsignals as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_nsignals ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_nvcsw as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_nvcsw ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage > ( ) ) ) . ru_nivcsw as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( rusage ) , "::" , stringify ! ( ru_nivcsw ) ) ) ; } pub type rusage_info_t = * mut :: std :: os :: raw :: c_void ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage_info_v0 { pub ri_uuid : [ u8 ; 16usize ] , pub ri_user_time : u64 , pub ri_system_time : u64 , pub ri_pkg_idle_wkups : u64 , pub ri_interrupt_wkups : u64 , pub ri_pageins : u64 , pub ri_wired_size : u64 , pub ri_resident_size : u64 , pub ri_phys_footprint : u64 , pub ri_proc_start_abstime : u64 , pub ri_proc_exit_abstime : u64 , } # [ test ] fn bindgen_test_layout_rusage_info_v0 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage_info_v0 > ( ) , 96usize , concat ! ( "Size of: " , stringify ! ( rusage_info_v0 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage_info_v0 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage_info_v0 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_uuid as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_uuid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_user_time as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_system_time as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_pkg_idle_wkups as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_interrupt_wkups as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_pageins as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_wired_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_wired_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_resident_size as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_resident_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_phys_footprint as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_proc_start_abstime as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_proc_start_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v0 > ( ) ) ) . ri_proc_exit_abstime as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v0 ) , "::" , stringify ! ( ri_proc_exit_abstime ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage_info_v1 { pub ri_uuid : [ u8 ; 16usize ] , pub ri_user_time : u64 , pub ri_system_time : u64 , pub ri_pkg_idle_wkups : u64 , pub ri_interrupt_wkups : u64 , pub ri_pageins : u64 , pub ri_wired_size : u64 , pub ri_resident_size : u64 , pub ri_phys_footprint : u64 , pub ri_proc_start_abstime : u64 , pub ri_proc_exit_abstime : u64 , pub ri_child_user_time : u64 , pub ri_child_system_time : u64 , pub ri_child_pkg_idle_wkups : u64 , pub ri_child_interrupt_wkups : u64 , pub ri_child_pageins : u64 , pub ri_child_elapsed_abstime : u64 , } # [ test ] fn bindgen_test_layout_rusage_info_v1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage_info_v1 > ( ) , 144usize , concat ! ( "Size of: " , stringify ! ( rusage_info_v1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage_info_v1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage_info_v1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_uuid as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_uuid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_user_time as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_system_time as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_pkg_idle_wkups as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_interrupt_wkups as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_pageins as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_wired_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_wired_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_resident_size as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_resident_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_phys_footprint as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_proc_start_abstime as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_proc_start_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_proc_exit_abstime as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_proc_exit_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_user_time as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_system_time as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_pkg_idle_wkups as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_interrupt_wkups as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_pageins as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v1 > ( ) ) ) . ri_child_elapsed_abstime as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v1 ) , "::" , stringify ! ( ri_child_elapsed_abstime ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage_info_v2 { pub ri_uuid : [ u8 ; 16usize ] , pub ri_user_time : u64 , pub ri_system_time : u64 , pub ri_pkg_idle_wkups : u64 , pub ri_interrupt_wkups : u64 , pub ri_pageins : u64 , pub ri_wired_size : u64 , pub ri_resident_size : u64 , pub ri_phys_footprint : u64 , pub ri_proc_start_abstime : u64 , pub ri_proc_exit_abstime : u64 , pub ri_child_user_time : u64 , pub ri_child_system_time : u64 , pub ri_child_pkg_idle_wkups : u64 , pub ri_child_interrupt_wkups : u64 , pub ri_child_pageins : u64 , pub ri_child_elapsed_abstime : u64 , pub ri_diskio_bytesread : u64 , pub ri_diskio_byteswritten : u64 , } # [ test ] fn bindgen_test_layout_rusage_info_v2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage_info_v2 > ( ) , 160usize , concat ! ( "Size of: " , stringify ! ( rusage_info_v2 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage_info_v2 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage_info_v2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_uuid as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_uuid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_user_time as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_system_time as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_pkg_idle_wkups as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_interrupt_wkups as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_pageins as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_wired_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_wired_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_resident_size as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_resident_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_phys_footprint as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_proc_start_abstime as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_proc_start_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_proc_exit_abstime as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_proc_exit_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_user_time as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_system_time as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_pkg_idle_wkups as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_interrupt_wkups as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_pageins as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_child_elapsed_abstime as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_child_elapsed_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_diskio_bytesread as * const _ as usize } , 144usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_diskio_bytesread ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v2 > ( ) ) ) . ri_diskio_byteswritten as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v2 ) , "::" , stringify ! ( ri_diskio_byteswritten ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage_info_v3 { pub ri_uuid : [ u8 ; 16usize ] , pub ri_user_time : u64 , pub ri_system_time : u64 , pub ri_pkg_idle_wkups : u64 , pub ri_interrupt_wkups : u64 , pub ri_pageins : u64 , pub ri_wired_size : u64 , pub ri_resident_size : u64 , pub ri_phys_footprint : u64 , pub ri_proc_start_abstime : u64 , pub ri_proc_exit_abstime : u64 , pub ri_child_user_time : u64 , pub ri_child_system_time : u64 , pub ri_child_pkg_idle_wkups : u64 , pub ri_child_interrupt_wkups : u64 , pub ri_child_pageins : u64 , pub ri_child_elapsed_abstime : u64 , pub ri_diskio_bytesread : u64 , pub ri_diskio_byteswritten : u64 , pub ri_cpu_time_qos_default : u64 , pub ri_cpu_time_qos_maintenance : u64 , pub ri_cpu_time_qos_background : u64 , pub ri_cpu_time_qos_utility : u64 , pub ri_cpu_time_qos_legacy : u64 , pub ri_cpu_time_qos_user_initiated : u64 , pub ri_cpu_time_qos_user_interactive : u64 , pub ri_billed_system_time : u64 , pub ri_serviced_system_time : u64 , } # [ test ] fn bindgen_test_layout_rusage_info_v3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage_info_v3 > ( ) , 232usize , concat ! ( "Size of: " , stringify ! ( rusage_info_v3 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage_info_v3 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage_info_v3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_uuid as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_uuid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_user_time as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_system_time as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_pkg_idle_wkups as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_interrupt_wkups as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_pageins as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_wired_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_wired_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_resident_size as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_resident_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_phys_footprint as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_proc_start_abstime as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_proc_start_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_proc_exit_abstime as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_proc_exit_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_user_time as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_system_time as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_pkg_idle_wkups as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_interrupt_wkups as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_pageins as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_child_elapsed_abstime as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_child_elapsed_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_diskio_bytesread as * const _ as usize } , 144usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_diskio_bytesread ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_diskio_byteswritten as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_diskio_byteswritten ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_default as * const _ as usize } , 160usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_default ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_maintenance as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_maintenance ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_background as * const _ as usize } , 176usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_background ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_utility as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_utility ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_legacy as * const _ as usize } , 192usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_legacy ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_user_initiated as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_user_initiated ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_cpu_time_qos_user_interactive as * const _ as usize } , 208usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_cpu_time_qos_user_interactive ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_billed_system_time as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_billed_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v3 > ( ) ) ) . ri_serviced_system_time as * const _ as usize } , 224usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v3 ) , "::" , stringify ! ( ri_serviced_system_time ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rusage_info_v4 { pub ri_uuid : [ u8 ; 16usize ] , pub ri_user_time : u64 , pub ri_system_time : u64 , pub ri_pkg_idle_wkups : u64 , pub ri_interrupt_wkups : u64 , pub ri_pageins : u64 , pub ri_wired_size : u64 , pub ri_resident_size : u64 , pub ri_phys_footprint : u64 , pub ri_proc_start_abstime : u64 , pub ri_proc_exit_abstime : u64 , pub ri_child_user_time : u64 , pub ri_child_system_time : u64 , pub ri_child_pkg_idle_wkups : u64 , pub ri_child_interrupt_wkups : u64 , pub ri_child_pageins : u64 , pub ri_child_elapsed_abstime : u64 , pub ri_diskio_bytesread : u64 , pub ri_diskio_byteswritten : u64 , pub ri_cpu_time_qos_default : u64 , pub ri_cpu_time_qos_maintenance : u64 , pub ri_cpu_time_qos_background : u64 , pub ri_cpu_time_qos_utility : u64 , pub ri_cpu_time_qos_legacy : u64 , pub ri_cpu_time_qos_user_initiated : u64 , pub ri_cpu_time_qos_user_interactive : u64 , pub ri_billed_system_time : u64 , pub ri_serviced_system_time : u64 , pub ri_logical_writes : u64 , pub ri_lifetime_max_phys_footprint : u64 , pub ri_instructions : u64 , pub ri_cycles : u64 , pub ri_billed_energy : u64 , pub ri_serviced_energy : u64 , pub ri_interval_max_phys_footprint : u64 , pub ri_unused : [ u64 ; 1usize ] , } # [ test ] fn bindgen_test_layout_rusage_info_v4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rusage_info_v4 > ( ) , 296usize , concat ! ( "Size of: " , stringify ! ( rusage_info_v4 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rusage_info_v4 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rusage_info_v4 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_uuid as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_uuid ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_user_time as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_system_time as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_pkg_idle_wkups as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_interrupt_wkups as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_pageins as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_wired_size as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_wired_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_resident_size as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_resident_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_phys_footprint as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_proc_start_abstime as * const _ as usize } , 80usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_proc_start_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_proc_exit_abstime as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_proc_exit_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_user_time as * const _ as usize } , 96usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_user_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_system_time as * const _ as usize } , 104usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_pkg_idle_wkups as * const _ as usize } , 112usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_pkg_idle_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_interrupt_wkups as * const _ as usize } , 120usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_interrupt_wkups ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_pageins as * const _ as usize } , 128usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_pageins ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_child_elapsed_abstime as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_child_elapsed_abstime ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_diskio_bytesread as * const _ as usize } , 144usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_diskio_bytesread ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_diskio_byteswritten as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_diskio_byteswritten ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_default as * const _ as usize } , 160usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_default ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_maintenance as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_maintenance ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_background as * const _ as usize } , 176usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_background ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_utility as * const _ as usize } , 184usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_utility ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_legacy as * const _ as usize } , 192usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_legacy ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_user_initiated as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_user_initiated ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cpu_time_qos_user_interactive as * const _ as usize } , 208usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cpu_time_qos_user_interactive ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_billed_system_time as * const _ as usize } , 216usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_billed_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_serviced_system_time as * const _ as usize } , 224usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_serviced_system_time ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_logical_writes as * const _ as usize } , 232usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_logical_writes ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_lifetime_max_phys_footprint as * const _ as usize } , 240usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_lifetime_max_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_instructions as * const _ as usize } , 248usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_instructions ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_cycles as * const _ as usize } , 256usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_cycles ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_billed_energy as * const _ as usize } , 264usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_billed_energy ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_serviced_energy as * const _ as usize } , 272usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_serviced_energy ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_interval_max_phys_footprint as * const _ as usize } , 280usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_interval_max_phys_footprint ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rusage_info_v4 > ( ) ) ) . ri_unused as * const _ as usize } , 288usize , concat ! ( "Offset of field: " , stringify ! ( rusage_info_v4 ) , "::" , stringify ! ( ri_unused ) ) ) ; } pub type rusage_info_current = rusage_info_v4 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rlimit { pub rlim_cur : rlim_t , pub rlim_max : rlim_t , } # [ test ] fn bindgen_test_layout_rlimit ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rlimit > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( rlimit ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rlimit > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rlimit ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rlimit > ( ) ) ) . rlim_cur as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rlimit ) , "::" , stringify ! ( rlim_cur ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rlimit > ( ) ) ) . rlim_max as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( rlimit ) , "::" , stringify ! ( rlim_max ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct proc_rlimit_control_wakeupmon { pub wm_flags : u32 , pub wm_rate : i32 , } # [ test ] fn bindgen_test_layout_proc_rlimit_control_wakeupmon ( ) { assert_eq ! ( :: std :: mem :: size_of :: < proc_rlimit_control_wakeupmon > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( proc_rlimit_control_wakeupmon ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < proc_rlimit_control_wakeupmon > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( proc_rlimit_control_wakeupmon ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < proc_rlimit_control_wakeupmon > ( ) ) ) . wm_flags as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( proc_rlimit_control_wakeupmon ) , "::" , stringify ! ( wm_flags ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < proc_rlimit_control_wakeupmon > ( ) ) ) . wm_rate as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( proc_rlimit_control_wakeupmon ) , "::" , stringify ! ( wm_rate ) ) ) ; } extern "C" { # [ link_name = "\u{1}_getpriority" ] pub fn getpriority ( arg1 : :: std :: os :: raw :: c_int , arg2 : id_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_getiopolicy_np" ] pub fn getiopolicy_np ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_getrlimit" ] pub fn getrlimit ( arg1 : :: std :: os :: raw :: c_int , arg2 : * mut rlimit ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_getrusage" ] pub fn getrusage ( arg1 : :: std :: os :: raw :: c_int , arg2 : * mut rusage ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_setpriority" ] pub fn setpriority ( arg1 : :: std :: os :: raw :: c_int , arg2 : id_t , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_setiopolicy_np" ] pub fn setiopolicy_np ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: os :: raw :: c_int , arg3 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_setrlimit" ] pub fn setrlimit ( arg1 : :: std :: os :: raw :: c_int , arg2 : * const rlimit ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub union wait { pub w_status : :: std :: os :: raw :: c_int , pub w_T : wait__bindgen_ty_1 , pub w_S : wait__bindgen_ty_2 , _bindgen_union_align : u32 , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct wait__bindgen_ty_1 { pub _bitfield_1 : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > , pub __bindgen_align : [ u32 ; 0usize ] , } # [ test ] fn bindgen_test_layout_wait__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < wait__bindgen_ty_1 > ( ) , 4usize , concat ! ( "Size of: " , stringify ! ( wait__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < wait__bindgen_ty_1 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( wait__bindgen_ty_1 ) ) ) ; } impl wait__bindgen_ty_1 { # [ inline ] pub fn w_Termsig ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 0usize , 7u8 ) as u32 ) } } # [ inline ] pub fn set_w_Termsig ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 0usize , 7u8 , val as u64 ) } } # [ inline ] pub fn w_Coredump ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 7usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_w_Coredump ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 7usize , 1u8 , val as u64 ) } } # [ inline ] pub fn w_Retcode ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 8usize , 8u8 ) as u32 ) } } # [ inline ] pub fn set_w_Retcode ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 8usize , 8u8 , val as u64 ) } } # [ inline ] pub fn w_Filler ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 16usize , 16u8 ) as u32 ) } } # [ inline ] pub fn set_w_Filler ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 16usize , 16u8 , val as u64 ) } } # [ inline ] pub fn new_bitfield_1 ( w_Termsig : :: std :: os :: raw :: c_uint , w_Coredump : :: std :: os :: raw :: c_uint , w_Retcode : :: std :: os :: raw :: c_uint , w_Filler : :: std :: os :: raw :: c_uint ) -> __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > = Default :: default ( ) ; __bindgen_bitfield_unit . set ( 0usize , 7u8 , { let w_Termsig : u32 = unsafe { :: std :: mem :: transmute ( w_Termsig ) } ; w_Termsig as u64 } ) ; __bindgen_bitfield_unit . set ( 7usize , 1u8 , { let w_Coredump : u32 = unsafe { :: std :: mem :: transmute ( w_Coredump ) } ; w_Coredump as u64 } ) ; __bindgen_bitfield_unit . set ( 8usize , 8u8 , { let w_Retcode : u32 = unsafe { :: std :: mem :: transmute ( w_Retcode ) } ; w_Retcode as u64 } ) ; __bindgen_bitfield_unit . set ( 16usize , 16u8 , { let w_Filler : u32 = unsafe { :: std :: mem :: transmute ( w_Filler ) } ; w_Filler as u64 } ) ; __bindgen_bitfield_unit } } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct wait__bindgen_ty_2 { pub _bitfield_1 : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > , pub __bindgen_align : [ u32 ; 0usize ] , } # [ test ] fn bindgen_test_layout_wait__bindgen_ty_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < wait__bindgen_ty_2 > ( ) , 4usize , concat ! ( "Size of: " , stringify ! ( wait__bindgen_ty_2 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < wait__bindgen_ty_2 > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( wait__bindgen_ty_2 ) ) ) ; } impl wait__bindgen_ty_2 { # [ inline ] pub fn w_Stopval ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 0usize , 8u8 ) as u32 ) } } # [ inline ] pub fn set_w_Stopval ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 0usize , 8u8 , val as u64 ) } } # [ inline ] pub fn w_Stopsig ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 8usize , 8u8 ) as u32 ) } } # [ inline ] pub fn set_w_Stopsig ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 8usize , 8u8 , val as u64 ) } } # [ inline ] pub fn w_Filler ( & self ) -> :: std :: os :: raw :: c_uint { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 16usize , 16u8 ) as u32 ) } } # [ inline ] pub fn set_w_Filler ( & mut self , val : :: std :: os :: raw :: c_uint ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 16usize , 16u8 , val as u64 ) } } # [ inline ] pub fn new_bitfield_1 ( w_Stopval : :: std :: os :: raw :: c_uint , w_Stopsig : :: std :: os :: raw :: c_uint , w_Filler : :: std :: os :: raw :: c_uint ) -> __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u16 > = Default :: default ( ) ; __bindgen_bitfield_unit . set ( 0usize , 8u8 , { let w_Stopval : u32 = unsafe { :: std :: mem :: transmute ( w_Stopval ) } ; w_Stopval as u64 } ) ; __bindgen_bitfield_unit . set ( 8usize , 8u8 , { let w_Stopsig : u32 = unsafe { :: std :: mem :: transmute ( w_Stopsig ) } ; w_Stopsig as u64 } ) ; __bindgen_bitfield_unit . set ( 16usize , 16u8 , { let w_Filler : u32 = unsafe { :: std :: mem :: transmute ( w_Filler ) } ; w_Filler as u64 } ) ; __bindgen_bitfield_unit } } # [ test ] fn bindgen_test_layout_wait ( ) { assert_eq ! ( :: std :: mem :: size_of :: < wait > ( ) , 4usize , concat ! ( "Size of: " , stringify ! ( wait ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < wait > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( wait ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < wait > ( ) ) ) . w_status as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( wait ) , "::" , stringify ! ( w_status ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < wait > ( ) ) ) . w_T as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( wait ) , "::" , stringify ! ( w_T ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < wait > ( ) ) ) . w_S as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( wait ) , "::" , stringify ! ( w_S ) ) ) ; } extern "C" { # [ link_name = "\u{1}_wait" ] pub fn wait ( arg1 : * mut :: std :: os :: raw :: c_int ) -> pid_t ; } extern "C" { # [ link_name = "\u{1}_waitpid" ] pub fn waitpid ( arg1 : pid_t , arg2 : * mut :: std :: os :: raw :: c_int , arg3 : :: std :: os :: raw :: c_int ) -> pid_t ; } extern "C" { # [ link_name = "\u{1}_waitid" ] pub fn waitid ( arg1 : idtype_t , arg2 : id_t , arg3 : * mut siginfo_t , arg4 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_wait3" ] pub fn wait3 ( arg1 : * mut :: std :: os :: raw :: c_int , arg2 : :: std :: os :: raw :: c_int , arg3 : * mut rusage ) -> pid_t ; } extern "C" { # [ link_name = "\u{1}_wait4" ] pub fn wait4 ( arg1 : pid_t , arg2 : * mut :: std :: os :: raw :: c_int , arg3 : :: std :: os :: raw :: c_int , arg4 : * mut rusage ) -> pid_t ; } extern "C" { # [ link_name = "\u{1}_alloca" ] pub fn alloca ( arg1 : usize ) -> * mut :: std :: os :: raw :: c_void ; } pub type ct_rune_t = __darwin_ct_rune_t ; pub type rune_t = __darwin_rune_t ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct div_t { pub quot : :: std :: os :: raw :: c_int , pub rem : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout_div_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < div_t > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( div_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < div_t > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( div_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < div_t > ( ) ) ) . quot as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( div_t ) , "::" , stringify ! ( quot ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < div_t > ( ) ) ) . rem as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( div_t ) , "::" , stringify ! ( rem ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ldiv_t { pub quot : :: std :: os :: raw :: c_long , pub rem : :: std :: os :: raw :: c_long , } # [ test ] fn bindgen_test_layout_ldiv_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ldiv_t > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( ldiv_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ldiv_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ldiv_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ldiv_t > ( ) ) ) . quot as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( ldiv_t ) , "::" , stringify ! ( quot ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < ldiv_t > ( ) ) ) . rem as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( ldiv_t ) , "::" , stringify ! ( rem ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct lldiv_t { pub quot : :: std :: os :: raw :: c_longlong , pub rem : :: std :: os :: raw :: c_longlong , } # [ test ] fn bindgen_test_layout_lldiv_t ( ) { assert_eq ! ( :: std :: mem :: size_of :: < lldiv_t > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( lldiv_t ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < lldiv_t > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( lldiv_t ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < lldiv_t > ( ) ) ) . quot as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( lldiv_t ) , "::" , stringify ! ( quot ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < lldiv_t > ( ) ) ) . rem as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( lldiv_t ) , "::" , stringify ! ( rem ) ) ) ; } extern "C" { # [ link_name = "\u{1}___mb_cur_max" ] pub static mut __mb_cur_max : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_malloc" ] pub fn malloc ( __size : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_calloc" ] pub fn calloc ( __count : usize , __size : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_free" ] pub fn free ( arg1 : * mut :: std :: os :: raw :: c_void ) ; } extern "C" { # [ link_name = "\u{1}_realloc" ] pub fn realloc ( __ptr : * mut :: std :: os :: raw :: c_void , __size : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_valloc" ] pub fn valloc ( arg1 : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_posix_memalign" ] pub fn posix_memalign ( __memptr : * mut * mut :: std :: os :: raw :: c_void , __alignment : usize , __size : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_abort" ] pub fn abort ( ) ; } extern "C" { # [ link_name = "\u{1}_abs" ] pub fn abs ( arg1 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_atexit" ] pub fn atexit ( arg1 : :: std :: option :: Option < unsafe extern "C" fn ( ) > ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_atof" ] pub fn atof ( arg1 : * const :: std :: os :: raw :: c_char ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_atoi" ] pub fn atoi ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_atol" ] pub fn atol ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_atoll" ] pub fn atoll ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_longlong ; } extern "C" { # [ link_name = "\u{1}_bsearch" ] pub fn bsearch ( __key : * const :: std :: os :: raw :: c_void , __base : * const :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : :: 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 ; } extern "C" { # [ link_name = "\u{1}_div" ] pub fn div ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: os :: raw :: c_int ) -> div_t ; } extern "C" { # [ link_name = "\u{1}_exit" ] pub fn exit ( arg1 : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_getenv" ] pub fn getenv ( arg1 : * const :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_labs" ] pub fn labs ( arg1 : :: std :: os :: raw :: c_long ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_ldiv" ] pub fn ldiv ( arg1 : :: std :: os :: raw :: c_long , arg2 : :: std :: os :: raw :: c_long ) -> ldiv_t ; } extern "C" { # [ link_name = "\u{1}_llabs" ] pub fn llabs ( arg1 : :: std :: os :: raw :: c_longlong ) -> :: std :: os :: raw :: c_longlong ; } extern "C" { # [ link_name = "\u{1}_lldiv" ] pub fn lldiv ( arg1 : :: std :: os :: raw :: c_longlong , arg2 : :: std :: os :: raw :: c_longlong ) -> lldiv_t ; } extern "C" { # [ link_name = "\u{1}_mblen" ] pub fn mblen ( __s : * const :: std :: os :: raw :: c_char , __n : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_mbstowcs" ] pub fn mbstowcs ( arg1 : * mut wchar_t , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize ) -> usize ; } extern "C" { # [ link_name = "\u{1}_mbtowc" ] pub fn mbtowc ( arg1 : * mut wchar_t , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_qsort" ] pub fn qsort ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : :: 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 > ) ; } extern "C" { # [ link_name = "\u{1}_rand" ] pub fn rand ( ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_srand" ] pub fn srand ( arg1 : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_strtod" ] pub fn strtod ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_strtof" ] pub fn strtof ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char ) -> f32 ; } extern "C" { # [ link_name = "\u{1}_strtol" ] pub fn strtol ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_strtold" ] pub fn strtold ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_strtoll" ] pub fn strtoll ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_longlong ; } extern "C" { # [ link_name = "\u{1}_strtoul" ] pub fn strtoul ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_ulong ; } extern "C" { # [ link_name = "\u{1}_strtoull" ] pub fn strtoull ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_ulonglong ; } extern "C" { # [ link_name = "\u{1}_system" ] pub fn system ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_wcstombs" ] pub fn wcstombs ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const wchar_t , arg3 : usize ) -> usize ; } extern "C" { # [ link_name = "\u{1}_wctomb" ] pub fn wctomb ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : wchar_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__Exit" ] pub fn _Exit ( arg1 : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_a64l" ] pub fn a64l ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_drand48" ] pub fn drand48 ( ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_ecvt" ] pub fn ecvt ( arg1 : f64 , arg2 : :: std :: os :: raw :: c_int , arg3 : * mut :: std :: os :: raw :: c_int , arg4 : * mut :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_erand48" ] pub fn erand48 ( arg1 : * mut :: std :: os :: raw :: c_ushort ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_fcvt" ] pub fn fcvt ( arg1 : f64 , arg2 : :: std :: os :: raw :: c_int , arg3 : * mut :: std :: os :: raw :: c_int , arg4 : * mut :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_gcvt" ] pub fn gcvt ( arg1 : f64 , arg2 : :: std :: os :: raw :: c_int , arg3 : * mut :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_getsubopt" ] pub fn getsubopt ( arg1 : * mut * mut :: std :: os :: raw :: c_char , arg2 : * const * mut :: std :: os :: raw :: c_char , arg3 : * mut * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_grantpt" ] pub fn grantpt ( arg1 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_initstate" ] pub fn initstate ( arg1 : :: std :: os :: raw :: c_uint , arg2 : * mut :: std :: os :: raw :: c_char , arg3 : usize ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_jrand48" ] pub fn jrand48 ( arg1 : * mut :: std :: os :: raw :: c_ushort ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_l64a" ] pub fn l64a ( arg1 : :: std :: os :: raw :: c_long ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_lcong48" ] pub fn lcong48 ( arg1 : * mut :: std :: os :: raw :: c_ushort ) ; } extern "C" { # [ link_name = "\u{1}_lrand48" ] pub fn lrand48 ( ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_mktemp" ] pub fn mktemp ( arg1 : * mut :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_mkstemp" ] pub fn mkstemp ( arg1 : * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_mrand48" ] pub fn mrand48 ( ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_nrand48" ] pub fn nrand48 ( arg1 : * mut :: std :: os :: raw :: c_ushort ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_posix_openpt" ] pub fn posix_openpt ( arg1 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_ptsname" ] pub fn ptsname ( arg1 : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_ptsname_r" ] pub fn ptsname_r ( fildes : :: std :: os :: raw :: c_int , buffer : * mut :: std :: os :: raw :: c_char , buflen : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_putenv" ] pub fn putenv ( arg1 : * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_random" ] pub fn random ( ) -> :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_rand_r" ] pub fn rand_r ( arg1 : * mut :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_realpath$DARWIN_EXTSN" ] pub fn realpath ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * mut :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_seed48" ] pub fn seed48 ( arg1 : * mut :: std :: os :: raw :: c_ushort ) -> * mut :: std :: os :: raw :: c_ushort ; } extern "C" { # [ link_name = "\u{1}_setenv" ] pub fn setenv ( __name : * const :: std :: os :: raw :: c_char , __value : * const :: std :: os :: raw :: c_char , __overwrite : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_setkey" ] pub fn setkey ( arg1 : * const :: std :: os :: raw :: c_char ) ; } extern "C" { # [ link_name = "\u{1}_setstate" ] pub fn setstate ( arg1 : * const :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_srand48" ] pub fn srand48 ( arg1 : :: std :: os :: raw :: c_long ) ; } extern "C" { # [ link_name = "\u{1}_srandom" ] pub fn srandom ( arg1 : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_unlockpt" ] pub fn unlockpt ( arg1 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_unsetenv" ] pub fn unsetenv ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } pub type dev_t = __darwin_dev_t ; pub type mode_t = __darwin_mode_t ; extern "C" { # [ link_name = "\u{1}_arc4random" ] pub fn arc4random ( ) -> u32 ; } extern "C" { # [ link_name = "\u{1}_arc4random_addrandom" ] pub fn arc4random_addrandom ( arg1 : * mut :: std :: os :: raw :: c_uchar , arg2 : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ link_name = "\u{1}_arc4random_buf" ] pub fn arc4random_buf ( __buf : * mut :: std :: os :: raw :: c_void , __nbytes : usize ) ; } extern "C" { # [ link_name = "\u{1}_arc4random_stir" ] pub fn arc4random_stir ( ) ; } extern "C" { # [ link_name = "\u{1}_arc4random_uniform" ] pub fn arc4random_uniform ( __upper_bound : u32 ) -> u32 ; } extern "C" { # [ link_name = "\u{1}_atexit_b" ] pub fn atexit_b ( arg1 : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_bsearch_b" ] pub fn bsearch_b ( __key : * const :: std :: os :: raw :: c_void , __base : * const :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : * mut :: std :: os :: raw :: c_void ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_cgetcap" ] pub fn cgetcap ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_cgetclose" ] pub fn cgetclose ( ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetent" ] pub fn cgetent ( arg1 : * mut * mut :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char , arg3 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetfirst" ] pub fn cgetfirst ( arg1 : * mut * mut :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetmatch" ] pub fn cgetmatch ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetnext" ] pub fn cgetnext ( arg1 : * mut * mut :: std :: os :: raw :: c_char , arg2 : * mut * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetnum" ] pub fn cgetnum ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut :: std :: os :: raw :: c_long ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetset" ] pub fn cgetset ( arg1 : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetstr" ] pub fn cgetstr ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_cgetustr" ] pub fn cgetustr ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_daemon$1050" ] pub fn daemon ( arg1 : :: std :: os :: raw :: c_int , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_devname" ] pub fn devname ( arg1 : dev_t , arg2 : mode_t ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_devname_r" ] pub fn devname_r ( arg1 : dev_t , arg2 : mode_t , buf : * mut :: std :: os :: raw :: c_char , len : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_getbsize" ] pub fn getbsize ( arg1 : * mut :: std :: os :: raw :: c_int , arg2 : * mut :: std :: os :: raw :: c_long ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_getloadavg" ] pub fn getloadavg ( arg1 : * mut f64 , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_getprogname" ] pub fn getprogname ( ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_heapsort" ] pub fn heapsort ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : :: 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 > ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_heapsort_b" ] pub fn heapsort_b ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_mergesort" ] pub fn mergesort ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : :: 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 > ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_mergesort_b" ] pub fn mergesort_b ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_psort" ] pub fn psort ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : :: 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 > ) ; } extern "C" { # [ link_name = "\u{1}_psort_b" ] pub fn psort_b ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : * mut :: std :: os :: raw :: c_void ) ; } extern "C" { # [ link_name = "\u{1}_psort_r" ] pub fn psort_r ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , arg1 : * mut :: std :: os :: raw :: c_void , __compar : :: 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 > ) ; } extern "C" { # [ link_name = "\u{1}_qsort_b" ] pub fn qsort_b ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , __compar : * mut :: std :: os :: raw :: c_void ) ; } extern "C" { # [ link_name = "\u{1}_qsort_r" ] pub fn qsort_r ( __base : * mut :: std :: os :: raw :: c_void , __nel : usize , __width : usize , arg1 : * mut :: std :: os :: raw :: c_void , __compar : :: 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 > ) ; } extern "C" { # [ link_name = "\u{1}_radixsort" ] pub fn radixsort ( __base : * mut * const :: std :: os :: raw :: c_uchar , __nel : :: std :: os :: raw :: c_int , __table : * const :: std :: os :: raw :: c_uchar , __endbyte : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_setprogname" ] pub fn setprogname ( arg1 : * const :: std :: os :: raw :: c_char ) ; } extern "C" { # [ link_name = "\u{1}_sradixsort" ] pub fn sradixsort ( __base : * mut * const :: std :: os :: raw :: c_uchar , __nel : :: std :: os :: raw :: c_int , __table : * const :: std :: os :: raw :: c_uchar , __endbyte : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_sranddev" ] pub fn sranddev ( ) ; } extern "C" { # [ link_name = "\u{1}_srandomdev" ] pub fn srandomdev ( ) ; } extern "C" { # [ link_name = "\u{1}_reallocf" ] pub fn reallocf ( __ptr : * mut :: std :: os :: raw :: c_void , __size : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_strtoq" ] pub fn strtoq ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_longlong ; } extern "C" { # [ link_name = "\u{1}_strtouq" ] pub fn strtouq ( __str : * const :: std :: os :: raw :: c_char , __endptr : * mut * mut :: std :: os :: raw :: c_char , __base : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_ulonglong ; } extern "C" { # [ link_name = "\u{1}_suboptarg" ] pub static mut suboptarg : * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_nettle_memxor" ] pub fn nettle_memxor ( dst : * mut :: std :: os :: raw :: c_void , src : * const :: std :: os :: raw :: c_void , n : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_nettle_memxor3" ] pub fn nettle_memxor3 ( dst : * mut :: std :: os :: raw :: c_void , a : * const :: std :: os :: raw :: c_void , b : * const :: std :: os :: raw :: c_void , n : usize ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ link_name = "\u{1}_nettle_memeql_sec" ] pub fn nettle_memeql_sec ( a : * const :: std :: os :: raw :: c_void , b : * const :: std :: os :: raw :: c_void , n : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_cnd_memcpy" ] pub fn nettle_cnd_memcpy ( cnd : :: std :: os :: raw :: c_int , dst : * mut :: std :: os :: raw :: c_void , src : * const :: std :: os :: raw :: c_void , n : usize ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pbkdf2" ] pub fn nettle_pbkdf2 ( mac_ctx : * mut :: std :: os :: raw :: c_void , update : nettle_hash_update_func , digest : nettle_hash_digest_func , digest_size : usize , iterations : :: std :: os :: raw :: c_uint , salt_length : usize , salt : * const u8 , length : usize , dst : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pbkdf2_hmac_sha1" ] pub fn nettle_pbkdf2_hmac_sha1 ( key_length : usize , key : * const u8 , iterations : :: std :: os :: raw :: c_uint , salt_length : usize , salt : * const u8 , length : usize , dst : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pbkdf2_hmac_sha256" ] pub fn nettle_pbkdf2_hmac_sha256 ( key_length : usize , key : * const u8 , iterations : :: std :: os :: raw :: c_uint , salt_length : usize , salt : * const u8 , length : usize , dst : * mut u8 ) ; } pub type clock_t = __darwin_clock_t ; pub type time_t = __darwin_time_t ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct timespec { pub tv_sec : __darwin_time_t , pub tv_nsec : :: std :: os :: raw :: c_long , } # [ test ] fn bindgen_test_layout_timespec ( ) { assert_eq ! ( :: std :: mem :: size_of :: < timespec > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( timespec ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < timespec > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( timespec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < timespec > ( ) ) ) . tv_sec as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( timespec ) , "::" , stringify ! ( tv_sec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < timespec > ( ) ) ) . tv_nsec as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( timespec ) , "::" , stringify ! ( tv_nsec ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct tm { pub tm_sec : :: std :: os :: raw :: c_int , pub tm_min : :: std :: os :: raw :: c_int , pub tm_hour : :: std :: os :: raw :: c_int , pub tm_mday : :: std :: os :: raw :: c_int , pub tm_mon : :: std :: os :: raw :: c_int , pub tm_year : :: std :: os :: raw :: c_int , pub tm_wday : :: std :: os :: raw :: c_int , pub tm_yday : :: std :: os :: raw :: c_int , pub tm_isdst : :: std :: os :: raw :: c_int , pub tm_gmtoff : :: std :: os :: raw :: c_long , pub tm_zone : * mut :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout_tm ( ) { assert_eq ! ( :: std :: mem :: size_of :: < tm > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( tm ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < tm > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( tm ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_sec as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_sec ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_min as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_min ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_hour as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_hour ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_mday as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_mday ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_mon as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_mon ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_year as * const _ as usize } , 20usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_year ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_wday as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_wday ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_yday as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_yday ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_isdst as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_isdst ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_gmtoff as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_gmtoff ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < tm > ( ) ) ) . tm_zone as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( tm ) , "::" , stringify ! ( tm_zone ) ) ) ; } extern "C" { # [ link_name = "\u{1}_tzname" ] pub static mut tzname : [ * mut :: std :: os :: raw :: c_char ; 0usize ] ; } extern "C" { # [ link_name = "\u{1}_getdate_err" ] pub static mut getdate_err : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_timezone" ] pub static mut timezone : :: std :: os :: raw :: c_long ; } extern "C" { # [ link_name = "\u{1}_daylight" ] pub static mut daylight : :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_asctime" ] pub fn asctime ( arg1 : * const tm ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_clock" ] pub fn clock ( ) -> clock_t ; } extern "C" { # [ link_name = "\u{1}_ctime" ] pub fn ctime ( arg1 : * const time_t ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_difftime" ] pub fn difftime ( arg1 : time_t , arg2 : time_t ) -> f64 ; } extern "C" { # [ link_name = "\u{1}_getdate" ] pub fn getdate ( arg1 : * const :: std :: os :: raw :: c_char ) -> * mut tm ; } extern "C" { # [ link_name = "\u{1}_gmtime" ] pub fn gmtime ( arg1 : * const time_t ) -> * mut tm ; } extern "C" { # [ link_name = "\u{1}_localtime" ] pub fn localtime ( arg1 : * const time_t ) -> * mut tm ; } extern "C" { # [ link_name = "\u{1}_mktime" ] pub fn mktime ( arg1 : * mut tm ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_strftime" ] pub fn strftime ( arg1 : * mut :: std :: os :: raw :: c_char , arg2 : usize , arg3 : * const :: std :: os :: raw :: c_char , arg4 : * const tm ) -> usize ; } extern "C" { # [ link_name = "\u{1}_strptime" ] pub fn strptime ( arg1 : * const :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut tm ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_time" ] pub fn time ( arg1 : * mut time_t ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_tzset" ] pub fn tzset ( ) ; } extern "C" { # [ link_name = "\u{1}_asctime_r" ] pub fn asctime_r ( arg1 : * const tm , arg2 : * mut :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_ctime_r" ] pub fn ctime_r ( arg1 : * const time_t , arg2 : * mut :: std :: os :: raw :: c_char ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_gmtime_r" ] pub fn gmtime_r ( arg1 : * const time_t , arg2 : * mut tm ) -> * mut tm ; } extern "C" { # [ link_name = "\u{1}_localtime_r" ] pub fn localtime_r ( arg1 : * const time_t , arg2 : * mut tm ) -> * mut tm ; } extern "C" { # [ link_name = "\u{1}_posix2time" ] pub fn posix2time ( arg1 : time_t ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_tzsetwall" ] pub fn tzsetwall ( ) ; } extern "C" { # [ link_name = "\u{1}_time2posix" ] pub fn time2posix ( arg1 : time_t ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_timelocal" ] pub fn timelocal ( arg1 : * mut tm ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_timegm" ] pub fn timegm ( arg1 : * mut tm ) -> time_t ; } extern "C" { # [ link_name = "\u{1}_nanosleep" ] pub fn nanosleep ( __rqtp : * const timespec , __rmtp : * mut timespec ) -> :: std :: os :: raw :: c_int ; } pub const clockid_t__CLOCK_REALTIME : clockid_t = 0 ; pub const clockid_t__CLOCK_MONOTONIC : clockid_t = 6 ; pub const clockid_t__CLOCK_MONOTONIC_RAW : clockid_t = 4 ; pub const clockid_t__CLOCK_MONOTONIC_RAW_APPROX : clockid_t = 5 ; pub const clockid_t__CLOCK_UPTIME_RAW : clockid_t = 8 ; pub const clockid_t__CLOCK_UPTIME_RAW_APPROX : clockid_t = 9 ; pub const clockid_t__CLOCK_PROCESS_CPUTIME_ID : clockid_t = 12 ; pub const clockid_t__CLOCK_THREAD_CPUTIME_ID : clockid_t = 16 ; pub type clockid_t = u32 ; extern "C" { # [ link_name = "\u{1}_clock_getres" ] pub fn clock_getres ( __clock_id : clockid_t , __res : * mut timespec ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_clock_gettime" ] pub fn clock_gettime ( __clock_id : clockid_t , __tp : * mut timespec ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_clock_gettime_nsec_np" ] pub fn clock_gettime_nsec_np ( __clock_id : clockid_t ) -> __uint64_t ; } extern "C" { # [ link_name = "\u{1}_clock_settime" ] pub fn clock_settime ( __clock_id : clockid_t , __tp : * const timespec ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_uint32" ] pub fn nettle_pgp_put_uint32 ( buffer : * mut nettle_buffer , i : u32 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_uint16" ] pub fn nettle_pgp_put_uint16 ( buffer : * mut nettle_buffer , i : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_mpi" ] pub fn nettle_pgp_put_mpi ( buffer : * mut nettle_buffer , x : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_string" ] pub fn nettle_pgp_put_string ( buffer : * mut nettle_buffer , length : :: std :: os :: raw :: c_uint , s : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_length" ] pub fn nettle_pgp_put_length ( buffer : * mut nettle_buffer , length : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_header" ] pub fn nettle_pgp_put_header ( buffer : * mut nettle_buffer , tag : :: std :: os :: raw :: c_uint , length : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_header_length" ] pub fn nettle_pgp_put_header_length ( buffer : * mut nettle_buffer , start : :: std :: os :: raw :: c_uint , field_size : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_sub_packet_start" ] pub fn nettle_pgp_sub_packet_start ( buffer : * mut nettle_buffer ) -> :: std :: os :: raw :: c_uint ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_sub_packet" ] pub fn nettle_pgp_put_sub_packet ( buffer : * mut nettle_buffer , type_ : :: std :: os :: raw :: c_uint , length : :: std :: os :: raw :: c_uint , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_sub_packet_end" ] pub fn nettle_pgp_sub_packet_end ( buffer : * mut nettle_buffer , start : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_public_rsa_key" ] pub fn nettle_pgp_put_public_rsa_key ( arg1 : * mut nettle_buffer , key : * const rsa_public_key , timestamp : time_t ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_rsa_sha1_signature" ] pub fn nettle_pgp_put_rsa_sha1_signature ( buffer : * mut nettle_buffer , key : * const rsa_private_key , keyid : * const u8 , type_ : :: std :: os :: raw :: c_uint , hash : * mut sha1_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_put_userid" ] pub fn nettle_pgp_put_userid ( buffer : * mut nettle_buffer , length : :: std :: os :: raw :: c_uint , name : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_crc24" ] pub fn nettle_pgp_crc24 ( length : :: std :: os :: raw :: c_uint , data : * const u8 ) -> u32 ; } extern "C" { # [ link_name = "\u{1}_nettle_pgp_armor" ] pub fn nettle_pgp_armor ( buffer : * mut nettle_buffer , tag : * const :: std :: os :: raw :: c_char , length : :: std :: os :: raw :: c_uint , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } pub const pgp_lengths_PGP_LENGTH_ONE_OCTET : pgp_lengths = 0 ; pub const pgp_lengths_PGP_LENGTH_TWO_OCTETS : pgp_lengths = 192 ; pub const pgp_lengths_PGP_LENGTH_FOUR_OCTETS : pgp_lengths = 8384 ; pub type pgp_lengths = u32 ; pub const pgp_public_key_algorithm_PGP_RSA : pgp_public_key_algorithm = 1 ; pub const pgp_public_key_algorithm_PGP_RSA_ENCRYPT : pgp_public_key_algorithm = 2 ; pub const pgp_public_key_algorithm_PGP_RSA_SIGN : pgp_public_key_algorithm = 3 ; pub const pgp_public_key_algorithm_PGP_EL_GAMAL_ENCRYPT : pgp_public_key_algorithm = 16 ; pub const pgp_public_key_algorithm_PGP_DSA : pgp_public_key_algorithm = 17 ; pub const pgp_public_key_algorithm_PGP_EL_GAMAL : pgp_public_key_algorithm = 20 ; pub type pgp_public_key_algorithm = u32 ; pub const pgp_symmetric_algorithm_PGP_PLAINTEXT : pgp_symmetric_algorithm = 0 ; pub const pgp_symmetric_algorithm_PGP_IDEA : pgp_symmetric_algorithm = 1 ; pub const pgp_symmetric_algorithm_PGP_3DES : pgp_symmetric_algorithm = 2 ; pub const pgp_symmetric_algorithm_PGP_CAST5 : pgp_symmetric_algorithm = 3 ; pub const pgp_symmetric_algorithm_PGP_BLOWFISH : pgp_symmetric_algorithm = 4 ; pub const pgp_symmetric_algorithm_PGP_SAFER_SK : pgp_symmetric_algorithm = 5 ; pub const pgp_symmetric_algorithm_PGP_AES128 : pgp_symmetric_algorithm = 7 ; pub const pgp_symmetric_algorithm_PGP_AES192 : pgp_symmetric_algorithm = 8 ; pub const pgp_symmetric_algorithm_PGP_AES256 : pgp_symmetric_algorithm = 9 ; pub type pgp_symmetric_algorithm = u32 ; pub const pgp_compression_algorithm_PGP_UNCOMPRESSED : pgp_compression_algorithm = 0 ; pub const pgp_compression_algorithm_PGP_ZIP : pgp_compression_algorithm = 1 ; pub const pgp_compression_algorithm_PGP_ZLIB : pgp_compression_algorithm = 2 ; pub type pgp_compression_algorithm = u32 ; pub const pgp_hash_algorithm_PGP_MD5 : pgp_hash_algorithm = 1 ; pub const pgp_hash_algorithm_PGP_SHA1 : pgp_hash_algorithm = 2 ; pub const pgp_hash_algorithm_PGP_RIPEMD : pgp_hash_algorithm = 3 ; pub const pgp_hash_algorithm_PGP_MD2 : pgp_hash_algorithm = 5 ; pub const pgp_hash_algorithm_PGP_TIGER192 : pgp_hash_algorithm = 6 ; pub const pgp_hash_algorithm_PGP_HAVAL : pgp_hash_algorithm = 7 ; pub type pgp_hash_algorithm = u32 ; pub const pgp_tag_PGP_TAG_PUBLIC_SESSION_KEY : pgp_tag = 1 ; pub const pgp_tag_PGP_TAG_SIGNATURE : pgp_tag = 2 ; pub const pgp_tag_PGP_TAG_SYMMETRIC_SESSION_KEY : pgp_tag = 3 ; pub const pgp_tag_PGP_TAG_ONE_PASS_SIGNATURE : pgp_tag = 4 ; pub const pgp_tag_PGP_TAG_SECRET_KEY : pgp_tag = 5 ; pub const pgp_tag_PGP_TAG_PUBLIC_KEY : pgp_tag = 6 ; pub const pgp_tag_PGP_TAG_SECRET_SUBKEY : pgp_tag = 7 ; pub const pgp_tag_PGP_TAG_COMPRESSED : pgp_tag = 8 ; pub const pgp_tag_PGP_TAG_ENCRYPTED : pgp_tag = 9 ; pub const pgp_tag_PGP_TAG_MARKER : pgp_tag = 10 ; pub const pgp_tag_PGP_TAG_LITERAL : pgp_tag = 11 ; pub const pgp_tag_PGP_TAG_TRUST : pgp_tag = 12 ; pub const pgp_tag_PGP_TAG_USERID : pgp_tag = 13 ; pub const pgp_tag_PGP_TAG_PUBLIC_SUBKEY : pgp_tag = 14 ; pub type pgp_tag = u32 ; pub const pgp_signature_type_PGP_SIGN_BINARY : pgp_signature_type = 0 ; pub const pgp_signature_type_PGP_SIGN_TEXT : pgp_signature_type = 1 ; pub const pgp_signature_type_PGP_SIGN_STANDALONE : pgp_signature_type = 2 ; pub const pgp_signature_type_PGP_SIGN_CERTIFICATION : pgp_signature_type = 16 ; pub const pgp_signature_type_PGP_SIGN_CERTIFICATION_PERSONA : pgp_signature_type = 17 ; pub const pgp_signature_type_PGP_SIGN_CERTIFICATION_CASUAL : pgp_signature_type = 18 ; pub const pgp_signature_type_PGP_SIGN_CERTIFICATION_POSITIVE : pgp_signature_type = 19 ; pub const pgp_signature_type_PGP_SIGN_SUBKEY : pgp_signature_type = 24 ; pub const pgp_signature_type_PGP_SIGN_KEY : pgp_signature_type = 31 ; pub const pgp_signature_type_PGP_SIGN_REVOCATION : pgp_signature_type = 32 ; pub const pgp_signature_type_PGP_SIGN_REVOCATION_SUBKEY : pgp_signature_type = 40 ; pub const pgp_signature_type_PGP_SIGN_REVOCATION_CERTIFICATE : pgp_signature_type = 48 ; pub const pgp_signature_type_PGP_SIGN_TIMESTAMP : pgp_signature_type = 64 ; pub type pgp_signature_type = u32 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_CREATION_TIME : pgp_subpacket_tag = 2 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_SIGNATURE_EXPIRATION_TIME : pgp_subpacket_tag = 3 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_EXPORTABLE_CERTIFICATION : pgp_subpacket_tag = 4 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_TRUST_SIGNATURE : pgp_subpacket_tag = 5 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_REGULAR_EXPRESSION : pgp_subpacket_tag = 6 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_REVOCABLE : pgp_subpacket_tag = 7 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_KEY_EXPIRATION_TIME : pgp_subpacket_tag = 9 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PLACEHOLDER : pgp_subpacket_tag = 10 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PREFERRED_SYMMETRIC_ALGORITHMS : pgp_subpacket_tag = 11 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_REVOCATION_KEY : pgp_subpacket_tag = 12 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_ISSUER_KEY_ID : pgp_subpacket_tag = 16 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_NOTATION_DATA : pgp_subpacket_tag = 20 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PREFERRED_HASH_ALGORITHMS : pgp_subpacket_tag = 21 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PREFERRED_COMPRESSION_ALGORITHMS : pgp_subpacket_tag = 22 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_KEY_SERVER_PREFERENCES : pgp_subpacket_tag = 23 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PREFERRED_KEY_SERVER : pgp_subpacket_tag = 24 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_PRIMARY_USER_ID : pgp_subpacket_tag = 25 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_POLICY_URL : pgp_subpacket_tag = 26 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_KEY_FLAGS : pgp_subpacket_tag = 27 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_SIGNERS_USER_ID : pgp_subpacket_tag = 28 ; pub const pgp_subpacket_tag_PGP_SUBPACKET_REASON_FOR_REVOCATION : pgp_subpacket_tag = 29 ; pub type pgp_subpacket_tag = u32 ; extern "C" { # [ link_name = "\u{1}__nettle_pkcs1_signature_prefix" ] pub fn _nettle_pkcs1_signature_prefix ( key_size : :: std :: os :: raw :: c_uint , buffer : * mut u8 , id_size : :: std :: os :: raw :: c_uint , id : * const u8 , digest_size : :: std :: os :: raw :: c_uint ) -> * mut u8 ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_encrypt" ] pub fn nettle_pkcs1_encrypt ( key_size : usize , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , length : usize , message : * const u8 , m : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_decrypt" ] pub fn nettle_pkcs1_decrypt ( key_size : usize , m : * mut __mpz_struct , length : * mut usize , message : * mut u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_digest_encode" ] pub fn nettle_pkcs1_rsa_digest_encode ( m : * mut __mpz_struct , key_size : usize , di_length : usize , digest_info : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_md5_encode" ] pub fn nettle_pkcs1_rsa_md5_encode ( m : * mut __mpz_struct , length : usize , hash : * mut md5_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_md5_encode_digest" ] pub fn nettle_pkcs1_rsa_md5_encode_digest ( m : * mut __mpz_struct , length : usize , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha1_encode" ] pub fn nettle_pkcs1_rsa_sha1_encode ( m : * mut __mpz_struct , length : usize , hash : * mut sha1_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha1_encode_digest" ] pub fn nettle_pkcs1_rsa_sha1_encode_digest ( m : * mut __mpz_struct , length : usize , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha256_encode" ] pub fn nettle_pkcs1_rsa_sha256_encode ( m : * mut __mpz_struct , length : usize , hash : * mut sha256_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha256_encode_digest" ] pub fn nettle_pkcs1_rsa_sha256_encode_digest ( m : * mut __mpz_struct , length : usize , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha512_encode" ] pub fn nettle_pkcs1_rsa_sha512_encode ( m : * mut __mpz_struct , length : usize , hash : * mut sha512_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pkcs1_rsa_sha512_encode_digest" ] pub fn nettle_pkcs1_rsa_sha512_encode_digest ( m : * mut __mpz_struct , length : usize , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pss_mgf1" ] pub fn nettle_pss_mgf1 ( seed : * const :: std :: os :: raw :: c_void , hash : * const nettle_hash , length : usize , mask : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_pss_encode_mgf1" ] pub fn nettle_pss_encode_mgf1 ( m : * mut __mpz_struct , bits : usize , hash : * const nettle_hash , salt_length : usize , salt : * const u8 , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_pss_verify_mgf1" ] pub fn nettle_pss_verify_mgf1 ( m : * mut __mpz_struct , bits : usize , hash : * const nettle_hash , salt_length : usize , digest : * const u8 ) -> :: std :: os :: raw :: c_int ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rsa_public_key { pub size : usize , pub n : mpz_t , pub e : mpz_t , } # [ test ] fn bindgen_test_layout_rsa_public_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rsa_public_key > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( rsa_public_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rsa_public_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rsa_public_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_public_key > ( ) ) ) . size as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rsa_public_key ) , "::" , stringify ! ( size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_public_key > ( ) ) ) . n as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( rsa_public_key ) , "::" , stringify ! ( n ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_public_key > ( ) ) ) . e as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rsa_public_key ) , "::" , stringify ! ( e ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct rsa_private_key { pub size : usize , pub d : mpz_t , pub p : mpz_t , pub q : mpz_t , pub a : mpz_t , pub b : mpz_t , pub c : mpz_t , } # [ test ] fn bindgen_test_layout_rsa_private_key ( ) { assert_eq ! ( :: std :: mem :: size_of :: < rsa_private_key > ( ) , 104usize , concat ! ( "Size of: " , stringify ! ( rsa_private_key ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < rsa_private_key > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( rsa_private_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . size as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . d as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( d ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . p as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( p ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . q as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( q ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . a as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( a ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . b as * const _ as usize } , 72usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( b ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < rsa_private_key > ( ) ) ) . c as * const _ as usize } , 88usize , concat ! ( "Offset of field: " , stringify ! ( rsa_private_key ) , "::" , stringify ! ( c ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_public_key_init" ] pub fn nettle_rsa_public_key_init ( key : * mut rsa_public_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_public_key_clear" ] pub fn nettle_rsa_public_key_clear ( key : * mut rsa_public_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_public_key_prepare" ] pub fn nettle_rsa_public_key_prepare ( key : * mut rsa_public_key ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_private_key_init" ] pub fn nettle_rsa_private_key_init ( key : * mut rsa_private_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_private_key_clear" ] pub fn nettle_rsa_private_key_clear ( key : * mut rsa_private_key ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_private_key_prepare" ] pub fn nettle_rsa_private_key_prepare ( key : * mut rsa_private_key ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pkcs1_sign" ] pub fn nettle_rsa_pkcs1_sign ( key : * const rsa_private_key , length : usize , digest_info : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pkcs1_sign_tr" ] pub fn nettle_rsa_pkcs1_sign_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , length : usize , digest_info : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pkcs1_verify" ] pub fn nettle_rsa_pkcs1_verify ( key : * const rsa_public_key , length : usize , digest_info : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_sign" ] pub fn nettle_rsa_md5_sign ( key : * const rsa_private_key , hash : * mut md5_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_sign_tr" ] pub fn nettle_rsa_md5_sign_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut md5_ctx , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_verify" ] pub fn nettle_rsa_md5_verify ( key : * const rsa_public_key , hash : * mut md5_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_sign" ] pub fn nettle_rsa_sha1_sign ( key : * const rsa_private_key , hash : * mut sha1_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_sign_tr" ] pub fn nettle_rsa_sha1_sign_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut sha1_ctx , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_verify" ] pub fn nettle_rsa_sha1_verify ( key : * const rsa_public_key , hash : * mut sha1_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_sign" ] pub fn nettle_rsa_sha256_sign ( key : * const rsa_private_key , hash : * mut sha256_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_sign_tr" ] pub fn nettle_rsa_sha256_sign_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut sha256_ctx , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_verify" ] pub fn nettle_rsa_sha256_verify ( key : * const rsa_public_key , hash : * mut sha256_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_sign" ] pub fn nettle_rsa_sha512_sign ( key : * const rsa_private_key , hash : * mut sha512_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_sign_tr" ] pub fn nettle_rsa_sha512_sign_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , hash : * mut sha512_ctx , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_verify" ] pub fn nettle_rsa_sha512_verify ( key : * const rsa_public_key , hash : * mut sha512_ctx , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_sign_digest" ] pub fn nettle_rsa_md5_sign_digest ( key : * const rsa_private_key , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_sign_digest_tr" ] pub fn nettle_rsa_md5_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_md5_verify_digest" ] pub fn nettle_rsa_md5_verify_digest ( key : * const rsa_public_key , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_sign_digest" ] pub fn nettle_rsa_sha1_sign_digest ( key : * const rsa_private_key , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_sign_digest_tr" ] pub fn nettle_rsa_sha1_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha1_verify_digest" ] pub fn nettle_rsa_sha1_verify_digest ( key : * const rsa_public_key , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_sign_digest" ] pub fn nettle_rsa_sha256_sign_digest ( key : * const rsa_private_key , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_sign_digest_tr" ] pub fn nettle_rsa_sha256_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha256_verify_digest" ] pub fn nettle_rsa_sha256_verify_digest ( key : * const rsa_public_key , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_sign_digest" ] pub fn nettle_rsa_sha512_sign_digest ( key : * const rsa_private_key , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_sign_digest_tr" ] pub fn nettle_rsa_sha512_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sha512_verify_digest" ] pub fn nettle_rsa_sha512_verify_digest ( key : * const rsa_public_key , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha256_sign_digest_tr" ] pub fn nettle_rsa_pss_sha256_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , salt_length : usize , salt : * const u8 , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha256_verify_digest" ] pub fn nettle_rsa_pss_sha256_verify_digest ( key : * const rsa_public_key , salt_length : usize , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha384_sign_digest_tr" ] pub fn nettle_rsa_pss_sha384_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , salt_length : usize , salt : * const u8 , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha384_verify_digest" ] pub fn nettle_rsa_pss_sha384_verify_digest ( key : * const rsa_public_key , salt_length : usize , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha512_sign_digest_tr" ] pub fn nettle_rsa_pss_sha512_sign_digest_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , salt_length : usize , salt : * const u8 , digest : * const u8 , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_pss_sha512_verify_digest" ] pub fn nettle_rsa_pss_sha512_verify_digest ( key : * const rsa_public_key , salt_length : usize , digest : * const u8 , signature : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_encrypt" ] pub fn nettle_rsa_encrypt ( key : * const rsa_public_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , length : usize , cleartext : * const u8 , cipher : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_decrypt" ] pub fn nettle_rsa_decrypt ( key : * const rsa_private_key , length : * mut usize , cleartext : * mut u8 , ciphertext : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_decrypt_tr" ] pub fn nettle_rsa_decrypt_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , length : * mut usize , message : * mut u8 , gibberish : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_sec_decrypt" ] pub fn nettle_rsa_sec_decrypt ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , length : usize , message : * mut u8 , gibberish : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_compute_root" ] pub fn nettle_rsa_compute_root ( key : * const rsa_private_key , x : * mut __mpz_struct , m : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_compute_root_tr" ] pub fn nettle_rsa_compute_root_tr ( pub_ : * const rsa_public_key , key : * const rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , x : * mut __mpz_struct , m : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_generate_keypair" ] pub fn nettle_rsa_generate_keypair ( pub_ : * mut rsa_public_key , key : * mut rsa_private_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , progress_ctx : * mut :: std :: os :: raw :: c_void , progress : nettle_progress_func , n_size : :: std :: os :: raw :: c_uint , e_size : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_keypair_to_sexp" ] pub fn nettle_rsa_keypair_to_sexp ( buffer : * mut nettle_buffer , algorithm_name : * const :: std :: os :: raw :: c_char , pub_ : * const rsa_public_key , priv_ : * const rsa_private_key ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_keypair_from_sexp_alist" ] pub fn nettle_rsa_keypair_from_sexp_alist ( pub_ : * mut rsa_public_key , priv_ : * mut rsa_private_key , limit : :: std :: os :: raw :: c_uint , i : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_keypair_from_sexp" ] pub fn nettle_rsa_keypair_from_sexp ( pub_ : * mut rsa_public_key , priv_ : * mut rsa_private_key , limit : :: std :: os :: raw :: c_uint , length : usize , expr : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_public_key_from_der_iterator" ] pub fn nettle_rsa_public_key_from_der_iterator ( pub_ : * mut rsa_public_key , limit : :: std :: os :: raw :: c_uint , i : * mut asn1_der_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_private_key_from_der_iterator" ] pub fn nettle_rsa_private_key_from_der_iterator ( pub_ : * mut rsa_public_key , priv_ : * mut rsa_private_key , limit : :: std :: os :: raw :: c_uint , i : * mut asn1_der_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_keypair_from_der" ] pub fn nettle_rsa_keypair_from_der ( pub_ : * mut rsa_public_key , priv_ : * mut rsa_private_key , limit : :: std :: os :: raw :: c_uint , length : usize , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_rsa_keypair_to_openpgp" ] pub fn nettle_rsa_keypair_to_openpgp ( buffer : * mut nettle_buffer , pub_ : * const rsa_public_key , priv_ : * const rsa_private_key , userid : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_rsa_verify" ] pub fn _nettle_rsa_verify ( key : * const rsa_public_key , m : * mut __mpz_struct , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_rsa_verify_recover" ] pub fn _nettle_rsa_verify_recover ( key : * const rsa_public_key , m : * mut __mpz_struct , s : * mut __mpz_struct ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}__nettle_rsa_check_size" ] pub fn _nettle_rsa_check_size ( n : * mut __mpz_struct ) -> usize ; } extern "C" { # [ link_name = "\u{1}__nettle_rsa_blind" ] pub fn _nettle_rsa_blind ( pub_ : * const rsa_public_key , random_ctx : * mut :: std :: os :: raw :: c_void , random : nettle_random_func , c : * mut __mpz_struct , ri : * mut __mpz_struct ) ; } extern "C" { # [ link_name = "\u{1}__nettle_rsa_unblind" ] pub fn _nettle_rsa_unblind ( pub_ : * const rsa_public_key , c : * mut __mpz_struct , ri : * mut __mpz_struct ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct salsa20_ctx { pub input : [ u32 ; 16usize ] , } # [ test ] fn bindgen_test_layout_salsa20_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < salsa20_ctx > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( salsa20_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < salsa20_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( salsa20_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < salsa20_ctx > ( ) ) ) . input as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( salsa20_ctx ) , "::" , stringify ! ( input ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20_128_set_key" ] pub fn nettle_salsa20_128_set_key ( ctx : * mut salsa20_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20_256_set_key" ] pub fn nettle_salsa20_256_set_key ( ctx : * mut salsa20_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20_set_key" ] pub fn nettle_salsa20_set_key ( ctx : * mut salsa20_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20_set_nonce" ] pub fn nettle_salsa20_set_nonce ( ctx : * mut salsa20_ctx , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20_crypt" ] pub fn nettle_salsa20_crypt ( ctx : * mut salsa20_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_salsa20r12_crypt" ] pub fn nettle_salsa20r12_crypt ( ctx : * mut salsa20_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_salsa20_core" ] pub fn _nettle_salsa20_core ( dst : * mut u32 , src : * const u32 , rounds : :: std :: os :: raw :: c_uint ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct serpent_ctx { pub keys : [ [ u32 ; 4usize ] ; 33usize ] , } # [ test ] fn bindgen_test_layout_serpent_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < serpent_ctx > ( ) , 528usize , concat ! ( "Size of: " , stringify ! ( serpent_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < serpent_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( serpent_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < serpent_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( serpent_ctx ) , "::" , stringify ! ( keys ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent_set_key" ] pub fn nettle_serpent_set_key ( ctx : * mut serpent_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent128_set_key" ] pub fn nettle_serpent128_set_key ( ctx : * mut serpent_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent192_set_key" ] pub fn nettle_serpent192_set_key ( ctx : * mut serpent_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent256_set_key" ] pub fn nettle_serpent256_set_key ( ctx : * mut serpent_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent_encrypt" ] pub fn nettle_serpent_encrypt ( ctx : * const serpent_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_serpent_decrypt" ] pub fn nettle_serpent_decrypt ( ctx : * const serpent_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } pub type va_list = __builtin_va_list ; pub type __gnuc_va_list = __builtin_va_list ; pub const sexp_type_SEXP_ATOM : sexp_type = 0 ; pub const sexp_type_SEXP_LIST : sexp_type = 1 ; pub const sexp_type_SEXP_END : sexp_type = 2 ; pub type sexp_type = u32 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct sexp_iterator { pub length : usize , pub buffer : * const u8 , pub start : usize , pub pos : usize , pub level : :: std :: os :: raw :: c_uint , pub type_ : sexp_type , pub display_length : usize , pub display : * const u8 , pub atom_length : usize , pub atom : * const u8 , } # [ test ] fn bindgen_test_layout_sexp_iterator ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sexp_iterator > ( ) , 72usize , concat ! ( "Size of: " , stringify ! ( sexp_iterator ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sexp_iterator > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sexp_iterator ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . length as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . buffer as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( buffer ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . start as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( start ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . pos as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( pos ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . level as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( level ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . type_ as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . display_length as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( display_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . display as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( display ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . atom_length as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( atom_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sexp_iterator > ( ) ) ) . atom as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( sexp_iterator ) , "::" , stringify ! ( atom ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_first" ] pub fn nettle_sexp_iterator_first ( iterator : * mut sexp_iterator , length : usize , input : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_transport_iterator_first" ] pub fn nettle_sexp_transport_iterator_first ( iterator : * mut sexp_iterator , length : usize , input : * mut u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_next" ] pub fn nettle_sexp_iterator_next ( iterator : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_enter_list" ] pub fn nettle_sexp_iterator_enter_list ( iterator : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_exit_list" ] pub fn nettle_sexp_iterator_exit_list ( iterator : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_subexpr" ] pub fn nettle_sexp_iterator_subexpr ( iterator : * mut sexp_iterator , length : * mut usize ) -> * const u8 ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_get_uint32" ] pub fn nettle_sexp_iterator_get_uint32 ( iterator : * mut sexp_iterator , x : * mut u32 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_check_type" ] pub fn nettle_sexp_iterator_check_type ( iterator : * mut sexp_iterator , type_ : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_check_types" ] pub fn nettle_sexp_iterator_check_types ( iterator : * mut sexp_iterator , ntypes : :: std :: os :: raw :: c_uint , types : * const * const :: std :: os :: raw :: c_char ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_iterator_assoc" ] pub fn nettle_sexp_iterator_assoc ( iterator : * mut sexp_iterator , nkeys : :: std :: os :: raw :: c_uint , keys : * const * const :: std :: os :: raw :: c_char , values : * mut sexp_iterator ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_format" ] pub fn nettle_sexp_format ( buffer : * mut nettle_buffer , format : * const :: std :: os :: raw :: c_char , ... ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_vformat" ] pub fn nettle_sexp_vformat ( buffer : * mut nettle_buffer , format : * const :: std :: os :: raw :: c_char , args : * mut __va_list_tag ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_transport_format" ] pub fn nettle_sexp_transport_format ( buffer : * mut nettle_buffer , format : * const :: std :: os :: raw :: c_char , ... ) -> usize ; } extern "C" { # [ link_name = "\u{1}_nettle_sexp_transport_vformat" ] pub fn nettle_sexp_transport_vformat ( buffer : * mut nettle_buffer , format : * const :: std :: os :: raw :: c_char , args : * mut __va_list_tag ) -> usize ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct sha3_state { pub a : [ u64 ; 25usize ] , } # [ test ] fn bindgen_test_layout_sha3_state ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha3_state > ( ) , 200usize , concat ! ( "Size of: " , stringify ! ( sha3_state ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha3_state > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha3_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_state > ( ) ) ) . a as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha3_state ) , "::" , stringify ! ( a ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_permute" ] pub fn nettle_sha3_permute ( state : * mut sha3_state ) ; } extern "C" { # [ link_name = "\u{1}__nettle_sha3_update" ] pub fn _nettle_sha3_update ( state : * mut sha3_state , block_size : :: std :: os :: raw :: c_uint , block : * mut u8 , pos : :: std :: os :: raw :: c_uint , length : usize , data : * const u8 ) -> :: std :: os :: raw :: c_uint ; } extern "C" { # [ link_name = "\u{1}__nettle_sha3_pad" ] pub fn _nettle_sha3_pad ( state : * mut sha3_state , block_size : :: std :: os :: raw :: c_uint , block : * mut u8 , pos : :: std :: os :: raw :: c_uint ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha3_224_ctx { pub state : sha3_state , pub index : :: std :: os :: raw :: c_uint , pub block : [ u8 ; 144usize ] , } # [ test ] fn bindgen_test_layout_sha3_224_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha3_224_ctx > ( ) , 352usize , concat ! ( "Size of: " , stringify ! ( sha3_224_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha3_224_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha3_224_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_224_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha3_224_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_224_ctx > ( ) ) ) . index as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( sha3_224_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_224_ctx > ( ) ) ) . block as * const _ as usize } , 204usize , concat ! ( "Offset of field: " , stringify ! ( sha3_224_ctx ) , "::" , stringify ! ( block ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_224_init" ] pub fn nettle_sha3_224_init ( ctx : * mut sha3_224_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_224_update" ] pub fn nettle_sha3_224_update ( ctx : * mut sha3_224_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_224_digest" ] pub fn nettle_sha3_224_digest ( ctx : * mut sha3_224_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha3_256_ctx { pub state : sha3_state , pub index : :: std :: os :: raw :: c_uint , pub block : [ u8 ; 136usize ] , } # [ test ] fn bindgen_test_layout_sha3_256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha3_256_ctx > ( ) , 344usize , concat ! ( "Size of: " , stringify ! ( sha3_256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha3_256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha3_256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_256_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha3_256_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_256_ctx > ( ) ) ) . index as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( sha3_256_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_256_ctx > ( ) ) ) . block as * const _ as usize } , 204usize , concat ! ( "Offset of field: " , stringify ! ( sha3_256_ctx ) , "::" , stringify ! ( block ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_256_init" ] pub fn nettle_sha3_256_init ( ctx : * mut sha3_256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_256_update" ] pub fn nettle_sha3_256_update ( ctx : * mut sha3_256_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_256_digest" ] pub fn nettle_sha3_256_digest ( ctx : * mut sha3_256_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha3_384_ctx { pub state : sha3_state , pub index : :: std :: os :: raw :: c_uint , pub block : [ u8 ; 104usize ] , } # [ test ] fn bindgen_test_layout_sha3_384_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha3_384_ctx > ( ) , 312usize , concat ! ( "Size of: " , stringify ! ( sha3_384_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha3_384_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha3_384_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_384_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha3_384_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_384_ctx > ( ) ) ) . index as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( sha3_384_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_384_ctx > ( ) ) ) . block as * const _ as usize } , 204usize , concat ! ( "Offset of field: " , stringify ! ( sha3_384_ctx ) , "::" , stringify ! ( block ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_384_init" ] pub fn nettle_sha3_384_init ( ctx : * mut sha3_384_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_384_update" ] pub fn nettle_sha3_384_update ( ctx : * mut sha3_384_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_384_digest" ] pub fn nettle_sha3_384_digest ( ctx : * mut sha3_384_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct sha3_512_ctx { pub state : sha3_state , pub index : :: std :: os :: raw :: c_uint , pub block : [ u8 ; 72usize ] , } # [ test ] fn bindgen_test_layout_sha3_512_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < sha3_512_ctx > ( ) , 280usize , concat ! ( "Size of: " , stringify ! ( sha3_512_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < sha3_512_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( sha3_512_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_512_ctx > ( ) ) ) . state as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( sha3_512_ctx ) , "::" , stringify ! ( state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_512_ctx > ( ) ) ) . index as * const _ as usize } , 200usize , concat ! ( "Offset of field: " , stringify ! ( sha3_512_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < sha3_512_ctx > ( ) ) ) . block as * const _ as usize } , 204usize , concat ! ( "Offset of field: " , stringify ! ( sha3_512_ctx ) , "::" , stringify ! ( block ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_512_init" ] pub fn nettle_sha3_512_init ( ctx : * mut sha3_512_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_512_update" ] pub fn nettle_sha3_512_update ( ctx : * mut sha3_512_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_sha3_512_digest" ] pub fn nettle_sha3_512_digest ( ctx : * mut sha3_512_ctx , length : usize , digest : * mut u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct twofish_ctx { pub keys : [ u32 ; 40usize ] , pub s_box : [ [ u32 ; 256usize ] ; 4usize ] , } # [ test ] fn bindgen_test_layout_twofish_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < twofish_ctx > ( ) , 4256usize , concat ! ( "Size of: " , stringify ! ( twofish_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < twofish_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( twofish_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < twofish_ctx > ( ) ) ) . keys as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( twofish_ctx ) , "::" , stringify ! ( keys ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < twofish_ctx > ( ) ) ) . s_box as * const _ as usize } , 160usize , concat ! ( "Offset of field: " , stringify ! ( twofish_ctx ) , "::" , stringify ! ( s_box ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish_set_key" ] pub fn nettle_twofish_set_key ( ctx : * mut twofish_ctx , length : usize , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish128_set_key" ] pub fn nettle_twofish128_set_key ( context : * mut twofish_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish192_set_key" ] pub fn nettle_twofish192_set_key ( context : * mut twofish_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish256_set_key" ] pub fn nettle_twofish256_set_key ( context : * mut twofish_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish_encrypt" ] pub fn nettle_twofish_encrypt ( ctx : * const twofish_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_twofish_decrypt" ] pub fn nettle_twofish_decrypt ( ctx : * const twofish_ctx , length : usize , dst : * mut u8 , src : * const u8 ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct umac32_ctx { pub l1_key : [ u32 ; 256usize ] , pub l2_key : [ u32 ; 6usize ] , pub l3_key1 : [ u64 ; 8usize ] , pub l3_key2 : [ u32 ; 1usize ] , pub pdf_key : aes128_ctx , pub l2_state : [ u64 ; 3usize ] , pub nonce : [ u8 ; 16usize ] , pub nonce_length : :: std :: os :: raw :: c_ushort , pub nonce_low : :: std :: os :: raw :: c_ushort , pub pad_cache : [ u32 ; 4usize ] , pub index : :: std :: os :: raw :: c_uint , pub count : u64 , pub block : [ u8 ; 1024usize ] , } # [ test ] fn bindgen_test_layout_umac32_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < umac32_ctx > ( ) , 2392usize , concat ! ( "Size of: " , stringify ! ( umac32_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < umac32_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( umac32_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . l1_key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( l1_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . l2_key as * const _ as usize } , 1024usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( l2_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . l3_key1 as * const _ as usize } , 1048usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( l3_key1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . l3_key2 as * const _ as usize } , 1112usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( l3_key2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . pdf_key as * const _ as usize } , 1116usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( pdf_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . l2_state as * const _ as usize } , 1296usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( l2_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . nonce as * const _ as usize } , 1320usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . nonce_length as * const _ as usize } , 1336usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( nonce_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . nonce_low as * const _ as usize } , 1338usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( nonce_low ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . pad_cache as * const _ as usize } , 1340usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( pad_cache ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . index as * const _ as usize } , 1356usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . count as * const _ as usize } , 1360usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac32_ctx > ( ) ) ) . block as * const _ as usize } , 1368usize , concat ! ( "Offset of field: " , stringify ! ( umac32_ctx ) , "::" , stringify ! ( block ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct umac64_ctx { pub l1_key : [ u32 ; 260usize ] , pub l2_key : [ u32 ; 12usize ] , pub l3_key1 : [ u64 ; 16usize ] , pub l3_key2 : [ u32 ; 2usize ] , pub pdf_key : aes128_ctx , pub l2_state : [ u64 ; 6usize ] , pub nonce : [ u8 ; 16usize ] , pub nonce_length : :: std :: os :: raw :: c_ushort , pub nonce_low : :: std :: os :: raw :: c_ushort , pub pad_cache : [ u32 ; 4usize ] , pub index : :: std :: os :: raw :: c_uint , pub count : u64 , pub block : [ u8 ; 1024usize ] , } # [ test ] fn bindgen_test_layout_umac64_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < umac64_ctx > ( ) , 2520usize , concat ! ( "Size of: " , stringify ! ( umac64_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < umac64_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( umac64_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . l1_key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( l1_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . l2_key as * const _ as usize } , 1040usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( l2_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . l3_key1 as * const _ as usize } , 1088usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( l3_key1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . l3_key2 as * const _ as usize } , 1216usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( l3_key2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . pdf_key as * const _ as usize } , 1224usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( pdf_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . l2_state as * const _ as usize } , 1400usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( l2_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . nonce as * const _ as usize } , 1448usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . nonce_length as * const _ as usize } , 1464usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( nonce_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . nonce_low as * const _ as usize } , 1466usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( nonce_low ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . pad_cache as * const _ as usize } , 1468usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( pad_cache ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . index as * const _ as usize } , 1484usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . count as * const _ as usize } , 1488usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac64_ctx > ( ) ) ) . block as * const _ as usize } , 1496usize , concat ! ( "Offset of field: " , stringify ! ( umac64_ctx ) , "::" , stringify ! ( block ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct umac96_ctx { pub l1_key : [ u32 ; 264usize ] , pub l2_key : [ u32 ; 18usize ] , pub l3_key1 : [ u64 ; 24usize ] , pub l3_key2 : [ u32 ; 3usize ] , pub pdf_key : aes128_ctx , pub l2_state : [ u64 ; 9usize ] , pub nonce : [ u8 ; 16usize ] , pub nonce_length : :: std :: os :: raw :: c_ushort , pub index : :: std :: os :: raw :: c_uint , pub count : u64 , pub block : [ u8 ; 1024usize ] , } # [ test ] fn bindgen_test_layout_umac96_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < umac96_ctx > ( ) , 2640usize , concat ! ( "Size of: " , stringify ! ( umac96_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < umac96_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( umac96_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . l1_key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( l1_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . l2_key as * const _ as usize } , 1056usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( l2_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . l3_key1 as * const _ as usize } , 1128usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( l3_key1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . l3_key2 as * const _ as usize } , 1320usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( l3_key2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . pdf_key as * const _ as usize } , 1332usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( pdf_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . l2_state as * const _ as usize } , 1512usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( l2_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . nonce as * const _ as usize } , 1584usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . nonce_length as * const _ as usize } , 1600usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( nonce_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . index as * const _ as usize } , 1604usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . count as * const _ as usize } , 1608usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac96_ctx > ( ) ) ) . block as * const _ as usize } , 1616usize , concat ! ( "Offset of field: " , stringify ! ( umac96_ctx ) , "::" , stringify ! ( block ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct umac128_ctx { pub l1_key : [ u32 ; 268usize ] , pub l2_key : [ u32 ; 24usize ] , pub l3_key1 : [ u64 ; 32usize ] , pub l3_key2 : [ u32 ; 4usize ] , pub pdf_key : aes128_ctx , pub l2_state : [ u64 ; 12usize ] , pub nonce : [ u8 ; 16usize ] , pub nonce_length : :: std :: os :: raw :: c_ushort , pub index : :: std :: os :: raw :: c_uint , pub count : u64 , pub block : [ u8 ; 1024usize ] , } # [ test ] fn bindgen_test_layout_umac128_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < umac128_ctx > ( ) , 2768usize , concat ! ( "Size of: " , stringify ! ( umac128_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < umac128_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( umac128_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . l1_key as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( l1_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . l2_key as * const _ as usize } , 1072usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( l2_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . l3_key1 as * const _ as usize } , 1168usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( l3_key1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . l3_key2 as * const _ as usize } , 1424usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( l3_key2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . pdf_key as * const _ as usize } , 1440usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( pdf_key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . l2_state as * const _ as usize } , 1616usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( l2_state ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . nonce as * const _ as usize } , 1712usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( nonce ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . nonce_length as * const _ as usize } , 1728usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( nonce_length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . index as * const _ as usize } , 1732usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . count as * const _ as usize } , 1736usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < umac128_ctx > ( ) ) ) . block as * const _ as usize } , 1744usize , concat ! ( "Offset of field: " , stringify ! ( umac128_ctx ) , "::" , stringify ! ( block ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac32_set_key" ] pub fn nettle_umac32_set_key ( ctx : * mut umac32_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac64_set_key" ] pub fn nettle_umac64_set_key ( ctx : * mut umac64_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac96_set_key" ] pub fn nettle_umac96_set_key ( ctx : * mut umac96_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac128_set_key" ] pub fn nettle_umac128_set_key ( ctx : * mut umac128_ctx , key : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac32_set_nonce" ] pub fn nettle_umac32_set_nonce ( ctx : * mut umac32_ctx , nonce_length : usize , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac64_set_nonce" ] pub fn nettle_umac64_set_nonce ( ctx : * mut umac64_ctx , nonce_length : usize , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac96_set_nonce" ] pub fn nettle_umac96_set_nonce ( ctx : * mut umac96_ctx , nonce_length : usize , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac128_set_nonce" ] pub fn nettle_umac128_set_nonce ( ctx : * mut umac128_ctx , nonce_length : usize , nonce : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac32_update" ] pub fn nettle_umac32_update ( ctx : * mut umac32_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac64_update" ] pub fn nettle_umac64_update ( ctx : * mut umac64_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac96_update" ] pub fn nettle_umac96_update ( ctx : * mut umac96_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac128_update" ] pub fn nettle_umac128_update ( ctx : * mut umac128_ctx , length : usize , data : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac32_digest" ] pub fn nettle_umac32_digest ( ctx : * mut umac32_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac64_digest" ] pub fn nettle_umac64_digest ( ctx : * mut umac64_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac96_digest" ] pub fn nettle_umac96_digest ( ctx : * mut umac96_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_umac128_digest" ] pub fn nettle_umac128_digest ( ctx : * mut umac128_ctx , length : usize , digest : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_set_key" ] pub fn _nettle_umac_set_key ( l1_key : * mut u32 , l2_key : * mut u32 , l3_key1 : * mut u64 , l3_key2 : * mut u32 , pad : * mut aes128_ctx , key : * const u8 , n : :: std :: os :: raw :: c_uint ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_nh" ] pub fn _nettle_umac_nh ( key : * const u32 , length : :: std :: os :: raw :: c_uint , msg : * const u8 ) -> u64 ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_nh_n" ] pub fn _nettle_umac_nh_n ( out : * mut u64 , n : :: std :: os :: raw :: c_uint , key : * const u32 , length : :: std :: os :: raw :: c_uint , msg : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_poly64" ] pub fn _nettle_umac_poly64 ( kh : u32 , kl : u32 , y : u64 , m : u64 ) -> u64 ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_poly128" ] pub fn _nettle_umac_poly128 ( k : * const u32 , y : * mut u64 , mh : u64 , ml : u64 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_l2_init" ] pub fn _nettle_umac_l2_init ( size : :: std :: os :: raw :: c_uint , k : * mut u32 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_l2" ] pub fn _nettle_umac_l2 ( key : * const u32 , state : * mut u64 , n : :: std :: os :: raw :: c_uint , count : u64 , m : * const u64 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_l2_final" ] pub fn _nettle_umac_l2_final ( key : * const u32 , state : * mut u64 , n : :: std :: os :: raw :: c_uint , count : u64 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_l3_init" ] pub fn _nettle_umac_l3_init ( size : :: std :: os :: raw :: c_uint , k : * mut u64 ) ; } extern "C" { # [ link_name = "\u{1}__nettle_umac_l3" ] pub fn _nettle_umac_l3 ( key : * const u64 , m : * const u64 ) -> u32 ; } pub const yarrow_pool_id_YARROW_FAST : yarrow_pool_id = 0 ; pub const yarrow_pool_id_YARROW_SLOW : yarrow_pool_id = 1 ; pub type yarrow_pool_id = u32 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct yarrow_source { pub estimate : [ u32 ; 2usize ] , pub next : yarrow_pool_id , } # [ test ] fn bindgen_test_layout_yarrow_source ( ) { assert_eq ! ( :: std :: mem :: size_of :: < yarrow_source > ( ) , 12usize , concat ! ( "Size of: " , stringify ! ( yarrow_source ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < yarrow_source > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( yarrow_source ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow_source > ( ) ) ) . estimate as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( yarrow_source ) , "::" , stringify ! ( estimate ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow_source > ( ) ) ) . next as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( yarrow_source ) , "::" , stringify ! ( next ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct yarrow256_ctx { pub pools : [ sha256_ctx ; 2usize ] , pub seeded : :: std :: os :: raw :: c_int , pub key : aes256_ctx , pub counter : [ u8 ; 16usize ] , pub nsources : :: std :: os :: raw :: c_uint , pub sources : * mut yarrow_source , } # [ test ] fn bindgen_test_layout_yarrow256_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < yarrow256_ctx > ( ) , 496usize , concat ! ( "Size of: " , stringify ! ( yarrow256_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < yarrow256_ctx > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( yarrow256_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . pools as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( pools ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . seeded as * const _ as usize } , 224usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( seeded ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . key as * const _ as usize } , 228usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( key ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . counter as * const _ as usize } , 468usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( counter ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . nsources as * const _ as usize } , 484usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( nsources ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow256_ctx > ( ) ) ) . sources as * const _ as usize } , 488usize , concat ! ( "Offset of field: " , stringify ! ( yarrow256_ctx ) , "::" , stringify ! ( sources ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_init" ] pub fn nettle_yarrow256_init ( ctx : * mut yarrow256_ctx , nsources : :: std :: os :: raw :: c_uint , sources : * mut yarrow_source ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_seed" ] pub fn nettle_yarrow256_seed ( ctx : * mut yarrow256_ctx , length : usize , seed_file : * const u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_update" ] pub fn nettle_yarrow256_update ( ctx : * mut yarrow256_ctx , source : :: std :: os :: raw :: c_uint , entropy : :: std :: os :: raw :: c_uint , length : usize , data : * const u8 ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_random" ] pub fn nettle_yarrow256_random ( ctx : * mut yarrow256_ctx , length : usize , dst : * mut u8 ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_is_seeded" ] pub fn nettle_yarrow256_is_seeded ( ctx : * mut yarrow256_ctx ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_needed_sources" ] pub fn nettle_yarrow256_needed_sources ( ctx : * mut yarrow256_ctx ) -> :: std :: os :: raw :: c_uint ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_fast_reseed" ] pub fn nettle_yarrow256_fast_reseed ( ctx : * mut yarrow256_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow256_slow_reseed" ] pub fn nettle_yarrow256_slow_reseed ( ctx : * mut yarrow256_ctx ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct yarrow_key_event_ctx { pub index : :: std :: os :: raw :: c_uint , pub chars : [ :: std :: os :: raw :: c_uint ; 16usize ] , pub previous : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout_yarrow_key_event_ctx ( ) { assert_eq ! ( :: std :: mem :: size_of :: < yarrow_key_event_ctx > ( ) , 72usize , concat ! ( "Size of: " , stringify ! ( yarrow_key_event_ctx ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < yarrow_key_event_ctx > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( yarrow_key_event_ctx ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow_key_event_ctx > ( ) ) ) . index as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( yarrow_key_event_ctx ) , "::" , stringify ! ( index ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow_key_event_ctx > ( ) ) ) . chars as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( yarrow_key_event_ctx ) , "::" , stringify ! ( chars ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < yarrow_key_event_ctx > ( ) ) ) . previous as * const _ as usize } , 68usize , concat ! ( "Offset of field: " , stringify ! ( yarrow_key_event_ctx ) , "::" , stringify ! ( previous ) ) ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow_key_event_init" ] pub fn nettle_yarrow_key_event_init ( ctx : * mut yarrow_key_event_ctx ) ; } extern "C" { # [ link_name = "\u{1}_nettle_yarrow_key_event_estimate" ] pub fn nettle_yarrow_key_event_estimate ( ctx : * mut yarrow_key_event_ctx , key : :: std :: os :: raw :: c_uint , time : :: std :: os :: raw :: c_uint ) -> :: std :: os :: raw :: c_uint ; } pub type __builtin_va_list = [ __va_list_tag ; 1usize ] ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct __va_list_tag { pub gp_offset : :: std :: os :: raw :: c_uint , pub fp_offset : :: std :: os :: raw :: c_uint , pub overflow_arg_area : * mut :: std :: os :: raw :: c_void , pub reg_save_area : * mut :: std :: os :: raw :: c_void , } # [ test ] fn bindgen_test_layout___va_list_tag ( ) { assert_eq ! ( :: std :: mem :: size_of :: < __va_list_tag > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( __va_list_tag ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < __va_list_tag > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( __va_list_tag ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __va_list_tag > ( ) ) ) . gp_offset as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( __va_list_tag ) , "::" , stringify ! ( gp_offset ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __va_list_tag > ( ) ) ) . fp_offset as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( __va_list_tag ) , "::" , stringify ! ( fp_offset ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __va_list_tag > ( ) ) ) . overflow_arg_area as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( __va_list_tag ) , "::" , stringify ! ( overflow_arg_area ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < __va_list_tag > ( ) ) ) . reg_save_area as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( __va_list_tag ) , "::" , stringify ! ( reg_save_area ) ) ) ; } \ No newline at end of file From bca68b389895657fbe3ba72b9f57053947b2e8f1 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Fri, 23 Jul 2021 09:19:32 +0200 Subject: [PATCH 08/10] IOS-2882 sequoia macOS works --- .../CommonPEPDependencies.xcodeproj/project.pbxproj | 2 +- buildcode/sequoia.code | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index 4bcf21e..d9fd0fa 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -802,7 +802,7 @@ ); runOnlyForDeploymentPostprocessing = 0; shellPath = "/bin/sh -l"; - shellScript = "# Note: `-l`(login shell) needed to find `wget`\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/build-sequoia-macOS.sh\" \nsh \"${BUILD_SCRIPT}\" \"${PREFIX}\"\n"; + shellScript = "# Note: `-l`(login shell) needed to find `wget`\nLIB_NAME=\"sequoia\"\n\nSCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\n\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/generate_and_run_mac_dependency_build_script.sh\" \nsh \"${BUILD_SCRIPT}\" $LIB_NAME \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; 1585EED9269EF98B00B822E1 /* Build */ = { diff --git a/buildcode/sequoia.code b/buildcode/sequoia.code index 089fb37..8bddb64 100644 --- a/buildcode/sequoia.code +++ b/buildcode/sequoia.code @@ -16,6 +16,8 @@ build_ios() cargo update rustup run nightly cargo update NETTLE_PREGENERATED_BINDINGS="${NETTLE_BINDINGS}" PKG_CONFIG_ALLOW_CROSS=1 RUST_BACKTRACE=1 PKG_CONFIG_PATH=$OUTPUT_DIR/${ARCH}/lib/pkgconfig RUSTFLAGS="-L ${CURRENT_LIB_DIR}/lib" rustup run nightly cargo build --target ${TARGET} -p sequoia-openpgp-ffi --release -Z build-std=core,alloc,std + # copy artefacts + cp "${SEQUOIA_DIR}/target/${TARGET}/release"/*.a "${CURRENT_LIB_DIR}/lib" } build_macos() @@ -34,6 +36,7 @@ build_macos() echo "Unhandled ARCH" exit 1 fi + cp "${SEQUOIA_DIR}/target/${HOST}/release"/*.a "${CURRENT_LIB_DIR}/lib" } @@ -45,6 +48,5 @@ pushd ${SEQUOIA_DIR} fi popd -# copy artefacts -cp "${SEQUOIA_DIR}/target/${TARGET}/release"/*.a "${CURRENT_LIB_DIR}/lib" +# copy headers cp -R "${SEQUOIA_DIR}/openpgp-ffi/include"/* "${CURRENT_LIB_DIR}/include/" \ No newline at end of file From bd7359e7850ecdcdc15089174f6009ec7d79be40 Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Fri, 23 Jul 2021 10:41:21 +0200 Subject: [PATCH 09/10] IOS-2882 betters naming of clean targets to not whipe things which you do not want to --- .../project.pbxproj | 12 ++-- ..._ALL.xcscheme => CLEAN_ALL_macOS.xcscheme} | 4 +- .../xcschemes/CLEAN_PEP_macOS.xcscheme | 67 +++++++++++++++++++ clean_pEp.sh => clean_pEp_macOS.sh | 0 4 files changed, 75 insertions(+), 8 deletions(-) rename CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/{CLEAN_ALL.xcscheme => CLEAN_ALL_macOS.xcscheme} (96%) create mode 100644 CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_PEP_macOS.xcscheme rename clean_pEp.sh => clean_pEp_macOS.sh (100%) diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index d9fd0fa..6f8e394 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -265,15 +265,15 @@ name = "build-downloadclient-dependencies_macOS"; productName = "build-pEpMIME-dependencies"; }; - 1585F04126A1C14C00B822E1 /* CLEAN_PEP */ = { + 1585F04126A1C14C00B822E1 /* CLEAN_PEP_macOS */ = { isa = PBXAggregateTarget; - buildConfigurationList = 1585F04726A1C14C00B822E1 /* Build configuration list for PBXAggregateTarget "CLEAN_PEP" */; + buildConfigurationList = 1585F04726A1C14C00B822E1 /* Build configuration list for PBXAggregateTarget "CLEAN_PEP_macOS" */; buildPhases = ( 1585F04626A1C14C00B822E1 /* Build */, ); dependencies = ( ); - name = CLEAN_PEP; + name = CLEAN_PEP_macOS; productName = "libetpan-dependencies_macOS"; }; 1585F04A26A1D2BE00B822E1 /* build-pEp4ThunderbirdInstaller-dependencies_macOS */ = { @@ -490,7 +490,7 @@ 1585EFAF26A178FE00B822E1 /* build-downloadclient-dependencies_macOS */, 1585F04A26A1D2BE00B822E1 /* build-pEp4ThunderbirdInstaller-dependencies_macOS */, 1585EEFC26A0432A00B822E1 /* CLEAN_ALL_macOS */, - 1585F04126A1C14C00B822E1 /* CLEAN_PEP */, + 1585F04126A1C14C00B822E1 /* CLEAN_PEP_macOS */, 152E498D26A9B252009BD3CE /* build_gmp_iOS */, 152E499926A9BC94009BD3CE /* build_nettle_iOS */, 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, @@ -878,7 +878,7 @@ ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; - shellScript = "SCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/clean_pEp.sh\" \nsh \"${BUILD_SCRIPT}\" \"${PREFIX}\"\n"; + shellScript = "SCRIPTS_DIR=\"${PROJECT_DIR}/..\"\nPREFIX=\"${PROJECT_DIR}/$(${SCRIPTS_DIR}/get-config-prefix.sh)\"\nBUILD_SCRIPT=\"${SCRIPTS_DIR}/clean_pEp_macOS.sh\" \nsh \"${BUILD_SCRIPT}\" \"${PREFIX}\"\n"; showEnvVarsInLog = 0; }; /* End PBXShellScriptBuildPhase section */ @@ -1646,7 +1646,7 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; - 1585F04726A1C14C00B822E1 /* Build configuration list for PBXAggregateTarget "CLEAN_PEP" */ = { + 1585F04726A1C14C00B822E1 /* Build configuration list for PBXAggregateTarget "CLEAN_PEP_macOS" */ = { isa = XCConfigurationList; buildConfigurations = ( 1585F04826A1C14C00B822E1 /* Debug */, diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL.xcscheme b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL_macOS.xcscheme similarity index 96% rename from CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL.xcscheme rename to CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL_macOS.xcscheme index bd04407..366c7d3 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL.xcscheme +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/xcshareddata/xcschemes/CLEAN_ALL_macOS.xcscheme @@ -3,8 +3,8 @@ LastUpgradeVersion = "1250" version = "1.3"> + parallelizeBuildables = "YES" + buildImplicitDependencies = "YES"> + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/clean_pEp.sh b/clean_pEp_macOS.sh similarity index 100% rename from clean_pEp.sh rename to clean_pEp_macOS.sh From e86b3adc08c1518d09eec81590041233f566de8c Mon Sep 17 00:00:00 2001 From: Andreas Buff Date: Fri, 23 Jul 2021 10:55:15 +0200 Subject: [PATCH 10/10] IOS-2882 sequoia depends on (and builds if required) custom build static libiconv now --- .../project.pbxproj | 28 ++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj index 6f8e394..ed2800b 100644 --- a/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj +++ b/CommonPEPDependencies/CommonPEPDependencies.xcodeproj/project.pbxproj @@ -213,6 +213,7 @@ 1585EECB269EF0F100B822E1 /* Build */, ); dependencies = ( + 152E49B826AABB0F009BD3CE /* PBXTargetDependency */, 152E49AA26A9CF2D009BD3CE /* PBXTargetDependency */, ); name = build_sequoia_macOS; @@ -247,6 +248,7 @@ 1585EF0626A0479800B822E1 /* Build */, ); dependencies = ( + 152E49B626AABB05009BD3CE /* PBXTargetDependency */, 152E49A126A9CED3009BD3CE /* PBXTargetDependency */, ); name = build_sequoia_iOS; @@ -319,6 +321,20 @@ remoteGlobalIDString = 152E49A226A9CEE0009BD3CE; remoteInfo = build_nettle_macOS; }; + 152E49B526AABB05009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 152E49AB26A9CFD4009BD3CE; + remoteInfo = build_libiconv_iOS; + }; + 152E49B726AABB0F009BD3CE /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 1585EE27269DD87700B822E1; + remoteInfo = build_libiconv_macOS; + }; 1585EE35269EC8DD00B822E1 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 1585EE0B269DC6DD00B822E1 /* Project object */; @@ -493,8 +509,8 @@ 1585F04126A1C14C00B822E1 /* CLEAN_PEP_macOS */, 152E498D26A9B252009BD3CE /* build_gmp_iOS */, 152E499926A9BC94009BD3CE /* build_nettle_iOS */, - 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, 152E49AB26A9CFD4009BD3CE /* build_libiconv_iOS */, + 1585EF0526A0479800B822E1 /* build_sequoia_iOS */, 152E47C626A5B7C2009BD3CE /* CLEAN_ALL_iOS */, ); }; @@ -904,6 +920,16 @@ target = 152E49A226A9CEE0009BD3CE /* build_nettle_macOS */; targetProxy = 152E49A926A9CF2D009BD3CE /* PBXContainerItemProxy */; }; + 152E49B626AABB05009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 152E49AB26A9CFD4009BD3CE /* build_libiconv_iOS */; + targetProxy = 152E49B526AABB05009BD3CE /* PBXContainerItemProxy */; + }; + 152E49B826AABB0F009BD3CE /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 1585EE27269DD87700B822E1 /* build_libiconv_macOS */; + targetProxy = 152E49B726AABB0F009BD3CE /* PBXContainerItemProxy */; + }; 1585EE36269EC8DD00B822E1 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 1585EE27269DD87700B822E1 /* build_libiconv_macOS */;