From 766d80092b0258a7974d4fca67603c9a052b38f5 Mon Sep 17 00:00:00 2001 From: Jannis Harder Date: Sun, 4 Aug 2024 13:49:53 +0200 Subject: [PATCH] Add partial low-level abc bindings --- .gitmodules | 3 + Cargo.lock | 27 + Cargo.toml | 1 + abc-sys/Cargo.toml | 10 + abc-sys/abc | 1 + abc-sys/build.rs | 114 + abc-sys/codegen.sh | 46 + abc-sys/src/bindings.cpp | 7 + abc-sys/src/bindings.h | 22 + abc-sys/src/generated/bindings.c | 910 ++ abc-sys/src/generated/bindings.d | 2 + abc-sys/src/generated/bindings.rs | 12676 ++++++++++++++++++++++++ abc-sys/src/generated/bindings.sha256 | 18 + abc-sys/src/lib.rs | 63 + 14 files changed, 13900 insertions(+) create mode 100644 .gitmodules create mode 100644 abc-sys/Cargo.toml create mode 160000 abc-sys/abc create mode 100644 abc-sys/build.rs create mode 100755 abc-sys/codegen.sh create mode 100644 abc-sys/src/bindings.cpp create mode 100644 abc-sys/src/bindings.h create mode 100644 abc-sys/src/generated/bindings.c create mode 100644 abc-sys/src/generated/bindings.d create mode 100644 abc-sys/src/generated/bindings.rs create mode 100644 abc-sys/src/generated/bindings.sha256 create mode 100644 abc-sys/src/lib.rs diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..7806677 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "abc-sys/abc"] + path = abc-sys/abc + url = https://github.com/YosysHQ/abc.git diff --git a/Cargo.lock b/Cargo.lock index 2c26741..a597f6e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -66,6 +66,16 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +[[package]] +name = "cc" +version = "1.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26a5c3fd7bfa1ce3897a3a3501d362b2d87b7f2583ebcb4a949ec25911025cbc" +dependencies = [ + "jobserver", + "libc", +] + [[package]] name = "cfg-if" version = "1.0.0" @@ -227,6 +237,14 @@ dependencies = [ "zwohash", ] +[[package]] +name = "imctk-abc-sys" +version = "0.1.0" +dependencies = [ + "cc", + "libc", +] + [[package]] name = "imctk-derive" version = "0.1.0" @@ -331,6 +349,15 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9028f49264629065d057f340a86acb84867925865f73bbf8d47b4d149a7e88b8" +[[package]] +name = "jobserver" +version = "0.1.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0" +dependencies = [ + "libc", +] + [[package]] name = "lazy_static" version = "1.5.0" diff --git a/Cargo.toml b/Cargo.toml index 79659fa..a99853d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ members = [ "logger", "util", "ir", + "abc-sys", # comment to force multi-line layout ] diff --git a/abc-sys/Cargo.toml b/abc-sys/Cargo.toml new file mode 100644 index 0000000..205e401 --- /dev/null +++ b/abc-sys/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "imctk-abc-sys" +version = "0.1.0" +edition = "2021" + +[dependencies] +libc = "0.2.155" + +[build-dependencies] +cc = { version = "1.1.7", features = ["jobserver", "parallel"] } diff --git a/abc-sys/abc b/abc-sys/abc new file mode 160000 index 0000000..28d955c --- /dev/null +++ b/abc-sys/abc @@ -0,0 +1 @@ +Subproject commit 28d955ca97a1c4be3aed4062aec0241a734fac5d diff --git a/abc-sys/build.rs b/abc-sys/build.rs new file mode 100644 index 0000000..6101dae --- /dev/null +++ b/abc-sys/build.rs @@ -0,0 +1,114 @@ +use std::path::PathBuf; + +static SRC_FILES: &[&str] = &[ + "abc/src/aig/gia/gia.h", + "abc/src/aig/gia/giaCSatP.c", + "abc/src/aig/gia/giaDup.c", + "abc/src/aig/gia/giaEquiv.c", + "abc/src/aig/gia/giaExist.c", + "abc/src/aig/gia/giaFanout.c", + "abc/src/aig/gia/giaHash.c", + "abc/src/aig/gia/giaMan.c", + "abc/src/aig/gia/giaScl.c", + "abc/src/aig/gia/giaSim.c", + "abc/src/aig/gia/giaUtil.c", + "abc/src/base/main/mainFrame.c", + "abc/src/base/main/mainReal.c", + "abc/src/misc/mem/mem.c", + "abc/src/misc/tim/timMan.c", + "abc/src/misc/util/utilBridge.c", + "abc/src/misc/util/utilCex.c", + "abc/src/misc/util/utilFile.c", + "abc/src/misc/util/utilSort.c", + "abc/src/proof/cec/cecSatG2.c", + "abc/src/proof/cec/cecSatG3.c", + "abc/src/sat/glucose2/AbcGlucose2.cpp", + "abc/src/sat/glucose2/AbcGlucoseCmd2.cpp", + "abc/src/sat/glucose2/Glucose2.cpp", + "abc/src/sat/glucose2/Options2.cpp", + "abc/src/sat/glucose2/SimpSolver2.cpp", + "abc/src/sat/glucose2/System2.cpp", + "src/bindings.cpp", +]; + +fn main() { + if std::path::Path::new("codegen.sh").exists() { + let status = std::process::Command::new("sh") + .arg("codegen.sh") + .spawn() + .expect("couldn't run codegen script") + .wait() + .expect("couldn't run codegen script"); + assert!(status.code() == Some(0), "codegen script failed"); + } + + if std::env::var("NO_SCCACHE").is_err() + && std::process::Command::new("sccache") + .arg("--version") + .status() + .is_ok() + { + std::env::set_var( + "CC", + format!("sccache {}", std::env::var("CC").as_deref().unwrap_or("cc")), + ); + std::env::set_var( + "CXX", + format!( + "sccache {}", + std::env::var("CXX").as_deref().unwrap_or("c++") + ), + ); + } + + let mut cc = cc::Build::new(); + + cc.warnings(false) + .define("ABC_USE_STDINT_H", "1") + .flag_if_supported("-Wno-unused-function") + .flag_if_supported("-Wno-write-strings") + .flag_if_supported("-Wno-sign-compare") + .include("abc/src") + .include("."); + + let mut cc_c = cc.clone(); + let mut cc_cpp = cc; + cc_cpp.cpp(true); + + cc_cpp.files(SRC_FILES.iter().filter(|&f| f.ends_with(".cpp"))); + cc_c.files(SRC_FILES.iter().filter(|&f| f.ends_with(".c"))); + + for file in SRC_FILES { + println!("cargo::rerun-if-changed={file}"); + } + + let mut deps_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap()); + deps_dir.push("deps"); + + let cc_deps = [cc_cpp.clone(), cc_c.clone()]; + + cc_cpp.objects(cc_c.compile_intermediates()); + cc_cpp.compile("imctk-abc"); + + for mut cc_dep in cc_deps { + cc_dep.out_dir(&deps_dir); + let Ok(dep_files) = cc_dep.flag("-M").try_compile_intermediates() else { + continue; + }; + + for path in dep_files { + let deps = std::fs::read_to_string(path).unwrap(); + + let Some((_c_file, headers)) = deps.split_once(':') else { + continue; + }; + + for header in headers + .split_ascii_whitespace() + .filter(|&part| !(part == "\\" || part.starts_with("/"))) + { + println!("cargo::rerun-if-changed={header}"); + } + } + } +} diff --git a/abc-sys/codegen.sh b/abc-sys/codegen.sh new file mode 100755 index 0000000..bee4505 --- /dev/null +++ b/abc-sys/codegen.sh @@ -0,0 +1,46 @@ +#!/bin/sh +set -eu +crate_dir=$(dirname "$0") +cd "$crate_dir" + +echo "cargo::rerun-if-changed=codegen.sh" + +if [ -f src/generated/bindings.d -a -f src/generated/bindings.sha256 ]; then + for file in $(cat src/generated/bindings.d); do + openssl dgst -sha256 $file + done | cmp src/generated/bindings.sha256 && { + for file in $(cat src/generated/bindings.d); do + echo "cargo::rerun-if-changed=$file" + done + exit; + } +fi + + +mkdir -p src/generated +bindgen \ + --allowlist-file src/bindings.h \ + $(find abc/src -name "*.h" | awk '{print "--allowlist-file", $1}') \ + --blocklist-item vnsprintf \ + --no-doc-comments \ + --no-recursive-allowlist \ + --experimental \ + --wrap-static-fns \ + --wrap-static-fns-path src/generated/bindings.c \ + --wrap-static-fns-suffix _imctk_abc_sys \ + --depfile src/generated/bindings.d \ + src/bindings.h \ + -- -I abc/src -D ABC_USE_STDINT_H \ + > src/generated/bindings.rs + +sed -Ee 's!(^.*?:| /[^ ]+)!!g' -i src/generated/bindings.d + +echo >> src/generated/bindings.d +echo "codegen.sh" >> src/generated/bindings.d + +for file in $(cat src/generated/bindings.d); do + openssl dgst -sha256 $file +done > src/generated/bindings.sha256 +for file in $(cat src/generated/bindings.d); do + echo "cargo::rerun-if-changed=$file" +done diff --git a/abc-sys/src/bindings.cpp b/abc-sys/src/bindings.cpp new file mode 100644 index 0000000..6fa2b95 --- /dev/null +++ b/abc-sys/src/bindings.cpp @@ -0,0 +1,7 @@ +#include "bindings.h" + +extern "C" { + +#include "generated/bindings.c" + +} diff --git a/abc-sys/src/bindings.h b/abc-sys/src/bindings.h new file mode 100644 index 0000000..b4a7cd1 --- /dev/null +++ b/abc-sys/src/bindings.h @@ -0,0 +1,22 @@ +#ifndef IMCTK_ABC_SYS_BINDINGS_H +#define IMCTK_ABC_SYS_BINDINGS_H + +#include "aig/gia/gia.h" +#include "misc/util/abc_global.h" +#include "proof/cec/cec.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void Cec4_ManSetParams(Cec_ParFra_t *pPars); +Gia_Man_t *Cec5_ManSimulateTest(Gia_Man_t *p, Cec_ParFra_t *pPars, + int fCbs, int approxLim, int subBatchSz, + + int adaRecycle); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/abc-sys/src/generated/bindings.c b/abc-sys/src/generated/bindings.c new file mode 100644 index 0000000..3c53ad9 --- /dev/null +++ b/abc-sys/src/generated/bindings.c @@ -0,0 +1,910 @@ +#include "src/bindings.h" + +// Static wrappers + +int Abc_AbsInt_imctk_abc_sys(int a) { return Abc_AbsInt(a); } +int Abc_MaxInt_imctk_abc_sys(int a, int b) { return Abc_MaxInt(a, b); } +int Abc_MinInt_imctk_abc_sys(int a, int b) { return Abc_MinInt(a, b); } +word Abc_MaxWord_imctk_abc_sys(word a, word b) { return Abc_MaxWord(a, b); } +word Abc_MinWord_imctk_abc_sys(word a, word b) { return Abc_MinWord(a, b); } +float Abc_AbsFloat_imctk_abc_sys(float a) { return Abc_AbsFloat(a); } +float Abc_MaxFloat_imctk_abc_sys(float a, float b) { return Abc_MaxFloat(a, b); } +float Abc_MinFloat_imctk_abc_sys(float a, float b) { return Abc_MinFloat(a, b); } +double Abc_AbsDouble_imctk_abc_sys(double a) { return Abc_AbsDouble(a); } +double Abc_MaxDouble_imctk_abc_sys(double a, double b) { return Abc_MaxDouble(a, b); } +double Abc_MinDouble_imctk_abc_sys(double a, double b) { return Abc_MinDouble(a, b); } +int Abc_Float2Int_imctk_abc_sys(float Val) { return Abc_Float2Int(Val); } +float Abc_Int2Float_imctk_abc_sys(int Num) { return Abc_Int2Float(Num); } +word Abc_Dbl2Word_imctk_abc_sys(double Dbl) { return Abc_Dbl2Word(Dbl); } +double Abc_Word2Dbl_imctk_abc_sys(word Num) { return Abc_Word2Dbl(Num); } +int Abc_Base2Log_imctk_abc_sys(unsigned int n) { return Abc_Base2Log(n); } +int Abc_Base10Log_imctk_abc_sys(unsigned int n) { return Abc_Base10Log(n); } +int Abc_Base16Log_imctk_abc_sys(unsigned int n) { return Abc_Base16Log(n); } +char * Abc_UtilStrsav_imctk_abc_sys(char *s) { return Abc_UtilStrsav(s); } +char * Abc_UtilStrsavTwo_imctk_abc_sys(char *s, char *a) { return Abc_UtilStrsavTwo(s, a); } +char * Abc_UtilStrsavNum_imctk_abc_sys(char *s, int n) { return Abc_UtilStrsavNum(s, n); } +int Abc_BitByteNum_imctk_abc_sys(int nBits) { return Abc_BitByteNum(nBits); } +int Abc_BitWordNum_imctk_abc_sys(int nBits) { return Abc_BitWordNum(nBits); } +int Abc_Bit6WordNum_imctk_abc_sys(int nBits) { return Abc_Bit6WordNum(nBits); } +int Abc_TruthByteNum_imctk_abc_sys(int nVars) { return Abc_TruthByteNum(nVars); } +int Abc_TruthWordNum_imctk_abc_sys(int nVars) { return Abc_TruthWordNum(nVars); } +int Abc_Truth6WordNum_imctk_abc_sys(int nVars) { return Abc_Truth6WordNum(nVars); } +int Abc_InfoHasBit_imctk_abc_sys(unsigned int *p, int i) { return Abc_InfoHasBit(p, i); } +void Abc_InfoSetBit_imctk_abc_sys(unsigned int *p, int i) { Abc_InfoSetBit(p, i); } +void Abc_InfoXorBit_imctk_abc_sys(unsigned int *p, int i) { Abc_InfoXorBit(p, i); } +unsigned int Abc_InfoMask_imctk_abc_sys(int nVar) { return Abc_InfoMask(nVar); } +int Abc_Var2Lit_imctk_abc_sys(int Var, int c) { return Abc_Var2Lit(Var, c); } +int Abc_Lit2Var_imctk_abc_sys(int Lit) { return Abc_Lit2Var(Lit); } +int Abc_LitIsCompl_imctk_abc_sys(int Lit) { return Abc_LitIsCompl(Lit); } +int Abc_LitNot_imctk_abc_sys(int Lit) { return Abc_LitNot(Lit); } +int Abc_LitNotCond_imctk_abc_sys(int Lit, int c) { return Abc_LitNotCond(Lit, c); } +int Abc_LitRegular_imctk_abc_sys(int Lit) { return Abc_LitRegular(Lit); } +int Abc_Lit2LitV_imctk_abc_sys(int *pMap, int Lit) { return Abc_Lit2LitV(pMap, Lit); } +int Abc_Lit2LitL_imctk_abc_sys(int *pMap, int Lit) { return Abc_Lit2LitL(pMap, Lit); } +int Abc_Ptr2Int_imctk_abc_sys(void *p) { return Abc_Ptr2Int(p); } +void * Abc_Int2Ptr_imctk_abc_sys(int i) { return Abc_Int2Ptr(i); } +word Abc_Ptr2Wrd_imctk_abc_sys(void *p) { return Abc_Ptr2Wrd(p); } +void * Abc_Wrd2Ptr_imctk_abc_sys(word i) { return Abc_Wrd2Ptr(i); } +int Abc_Var2Lit2_imctk_abc_sys(int Var, int Att) { return Abc_Var2Lit2(Var, Att); } +int Abc_Lit2Var2_imctk_abc_sys(int Lit) { return Abc_Lit2Var2(Lit); } +int Abc_Lit2Att2_imctk_abc_sys(int Lit) { return Abc_Lit2Att2(Lit); } +int Abc_Var2Lit3_imctk_abc_sys(int Var, int Att) { return Abc_Var2Lit3(Var, Att); } +int Abc_Lit2Var3_imctk_abc_sys(int Lit) { return Abc_Lit2Var3(Lit); } +int Abc_Lit2Att3_imctk_abc_sys(int Lit) { return Abc_Lit2Att3(Lit); } +int Abc_Var2Lit4_imctk_abc_sys(int Var, int Att) { return Abc_Var2Lit4(Var, Att); } +int Abc_Lit2Var4_imctk_abc_sys(int Lit) { return Abc_Lit2Var4(Lit); } +int Abc_Lit2Att4_imctk_abc_sys(int Lit) { return Abc_Lit2Att4(Lit); } +abctime Abc_Clock_imctk_abc_sys(void) { return Abc_Clock(); } +abctime Abc_ThreadClock_imctk_abc_sys(void) { return Abc_ThreadClock(); } +void Abc_PrintInt_imctk_abc_sys(int i) { Abc_PrintInt(i); } +void Abc_PrintTime_imctk_abc_sys(int level, const char *pStr, abctime time) { Abc_PrintTime(level, pStr, time); } +void Abc_PrintTimeP_imctk_abc_sys(int level, const char *pStr, abctime time, abctime Time) { Abc_PrintTimeP(level, pStr, time, Time); } +void Abc_PrintMemoryP_imctk_abc_sys(int level, const char *pStr, int mem, int Mem) { Abc_PrintMemoryP(level, pStr, mem, Mem); } +int Abc_PrimeCudd_imctk_abc_sys(unsigned int p) { return Abc_PrimeCudd(p); } +void * Abc_FileReadContents_imctk_abc_sys(char *pFileName, int *pnFileSize) { return Abc_FileReadContents(pFileName, pnFileSize); } +void Abc_ReverseOrder_imctk_abc_sys(int *pA, int nA) { Abc_ReverseOrder(pA, nA); } +Vec_Int_t * Vec_IntAlloc_imctk_abc_sys(int nCap) { return Vec_IntAlloc(nCap); } +Vec_Int_t * Vec_IntAllocExact_imctk_abc_sys(int nCap) { return Vec_IntAllocExact(nCap); } +Vec_Int_t * Vec_IntStart_imctk_abc_sys(int nSize) { return Vec_IntStart(nSize); } +Vec_Int_t * Vec_IntStartFull_imctk_abc_sys(int nSize) { return Vec_IntStartFull(nSize); } +Vec_Int_t * Vec_IntStartRange_imctk_abc_sys(int First, int Range) { return Vec_IntStartRange(First, Range); } +Vec_Int_t * Vec_IntStartRandomLimit_imctk_abc_sys(int nSize, int Upper, int Lower) { return Vec_IntStartRandomLimit(nSize, Upper, Lower); } +void Vec_IntRandomizeOrder_imctk_abc_sys(Vec_Int_t *p) { Vec_IntRandomizeOrder(p); } +Vec_Int_t * Vec_IntStartNatural_imctk_abc_sys(int nSize) { return Vec_IntStartNatural(nSize); } +Vec_Int_t * Vec_IntAllocArray_imctk_abc_sys(int *pArray, int nSize) { return Vec_IntAllocArray(pArray, nSize); } +Vec_Int_t * Vec_IntAllocArrayCopy_imctk_abc_sys(int *pArray, int nSize) { return Vec_IntAllocArrayCopy(pArray, nSize); } +Vec_Int_t * Vec_IntDup_imctk_abc_sys(Vec_Int_t *pVec) { return Vec_IntDup(pVec); } +Vec_Int_t * Vec_IntDupArray_imctk_abc_sys(Vec_Int_t *pVec) { return Vec_IntDupArray(pVec); } +void Vec_IntZero_imctk_abc_sys(Vec_Int_t *p) { Vec_IntZero(p); } +void Vec_IntErase_imctk_abc_sys(Vec_Int_t *p) { Vec_IntErase(p); } +void Vec_IntFree_imctk_abc_sys(Vec_Int_t *p) { Vec_IntFree(p); } +void Vec_IntFreeP_imctk_abc_sys(Vec_Int_t **p) { Vec_IntFreeP(p); } +int * Vec_IntReleaseArray_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntReleaseArray(p); } +int * Vec_IntReleaseNewArray_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntReleaseNewArray(p); } +int * Vec_IntArray_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntArray(p); } +int ** Vec_IntArrayP_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntArrayP(p); } +int * Vec_IntLimit_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntLimit(p); } +int Vec_IntSize_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntSize(p); } +int Vec_IntCap_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCap(p); } +double Vec_IntMemory_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntMemory(p); } +int Vec_IntEntry_imctk_abc_sys(Vec_Int_t *p, int i) { return Vec_IntEntry(p, i); } +int * Vec_IntEntryP_imctk_abc_sys(Vec_Int_t *p, int i) { return Vec_IntEntryP(p, i); } +void Vec_IntWriteEntry_imctk_abc_sys(Vec_Int_t *p, int i, int Entry) { Vec_IntWriteEntry(p, i, Entry); } +int Vec_IntAddToEntry_imctk_abc_sys(Vec_Int_t *p, int i, int Addition) { return Vec_IntAddToEntry(p, i, Addition); } +void Vec_IntUpdateEntry_imctk_abc_sys(Vec_Int_t *p, int i, int Value) { Vec_IntUpdateEntry(p, i, Value); } +void Vec_IntDowndateEntry_imctk_abc_sys(Vec_Int_t *p, int i, int Value) { Vec_IntDowndateEntry(p, i, Value); } +int Vec_IntEntryLast_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntEntryLast(p); } +void Vec_IntGrow_imctk_abc_sys(Vec_Int_t *p, int nCapMin) { Vec_IntGrow(p, nCapMin); } +void Vec_IntGrowResize_imctk_abc_sys(Vec_Int_t *p, int nCapMin) { Vec_IntGrowResize(p, nCapMin); } +void Vec_IntFill_imctk_abc_sys(Vec_Int_t *p, int nSize, int Fill) { Vec_IntFill(p, nSize, Fill); } +void Vec_IntFillTwo_imctk_abc_sys(Vec_Int_t *p, int nSize, int FillEven, int FillOdd) { Vec_IntFillTwo(p, nSize, FillEven, FillOdd); } +void Vec_IntFillNatural_imctk_abc_sys(Vec_Int_t *p, int nSize) { Vec_IntFillNatural(p, nSize); } +void Vec_IntFillExtra_imctk_abc_sys(Vec_Int_t *p, int nSize, int Fill) { Vec_IntFillExtra(p, nSize, Fill); } +int Vec_IntGetEntry_imctk_abc_sys(Vec_Int_t *p, int i) { return Vec_IntGetEntry(p, i); } +int Vec_IntGetEntryFull_imctk_abc_sys(Vec_Int_t *p, int i) { return Vec_IntGetEntryFull(p, i); } +int * Vec_IntGetEntryP_imctk_abc_sys(Vec_Int_t *p, int i) { return Vec_IntGetEntryP(p, i); } +void Vec_IntSetEntry_imctk_abc_sys(Vec_Int_t *p, int i, int Entry) { Vec_IntSetEntry(p, i, Entry); } +void Vec_IntSetEntryFull_imctk_abc_sys(Vec_Int_t *p, int i, int Entry) { Vec_IntSetEntryFull(p, i, Entry); } +void Vec_IntShrink_imctk_abc_sys(Vec_Int_t *p, int nSizeNew) { Vec_IntShrink(p, nSizeNew); } +void Vec_IntClear_imctk_abc_sys(Vec_Int_t *p) { Vec_IntClear(p); } +void Vec_IntPush_imctk_abc_sys(Vec_Int_t *p, int Entry) { Vec_IntPush(p, Entry); } +int Vec_IntPushReturn_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntPushReturn(p, Entry); } +void Vec_IntPushTwo_imctk_abc_sys(Vec_Int_t *p, int Entry1, int Entry2) { Vec_IntPushTwo(p, Entry1, Entry2); } +void Vec_IntPushThree_imctk_abc_sys(Vec_Int_t *p, int Entry1, int Entry2, int Entry3) { Vec_IntPushThree(p, Entry1, Entry2, Entry3); } +void Vec_IntPushFour_imctk_abc_sys(Vec_Int_t *p, int Entry1, int Entry2, int Entry3, int Entry4) { Vec_IntPushFour(p, Entry1, Entry2, Entry3, Entry4); } +void Vec_IntPushArray_imctk_abc_sys(Vec_Int_t *p, int *pEntries, int nEntries) { Vec_IntPushArray(p, pEntries, nEntries); } +void Vec_IntShift_imctk_abc_sys(Vec_Int_t *p, int Shift) { Vec_IntShift(p, Shift); } +void Vec_IntPushFirst_imctk_abc_sys(Vec_Int_t *p, int Entry) { Vec_IntPushFirst(p, Entry); } +void Vec_IntPushOrder_imctk_abc_sys(Vec_Int_t *p, int Entry) { Vec_IntPushOrder(p, Entry); } +void Vec_IntPushOrderCost_imctk_abc_sys(Vec_Int_t *p, int Entry, Vec_Int_t *vCost) { Vec_IntPushOrderCost(p, Entry, vCost); } +int Vec_IntIsOrdered_imctk_abc_sys(Vec_Int_t *p, int fReverse) { return Vec_IntIsOrdered(p, fReverse); } +int Vec_IntIsOrderedCost_imctk_abc_sys(Vec_Int_t *p, Vec_Int_t *vCost, int fReverse) { return Vec_IntIsOrderedCost(p, vCost, fReverse); } +void Vec_IntPushOrderReverse_imctk_abc_sys(Vec_Int_t *p, int Entry) { Vec_IntPushOrderReverse(p, Entry); } +int Vec_IntPushUniqueOrder_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntPushUniqueOrder(p, Entry); } +int Vec_IntPushUniqueOrderCost_imctk_abc_sys(Vec_Int_t *p, int Entry, Vec_Int_t *vCost) { return Vec_IntPushUniqueOrderCost(p, Entry, vCost); } +int Vec_IntPushUnique_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntPushUnique(p, Entry); } +unsigned int * Vec_IntFetch_imctk_abc_sys(Vec_Int_t *p, int nWords) { return Vec_IntFetch(p, nWords); } +int Vec_IntPop_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntPop(p); } +int Vec_IntFind_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntFind(p, Entry); } +int Vec_IntRemove_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntRemove(p, Entry); } +int Vec_IntRemove1_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntRemove1(p, Entry); } +void Vec_IntDrop_imctk_abc_sys(Vec_Int_t *p, int i) { Vec_IntDrop(p, i); } +void Vec_IntInsert_imctk_abc_sys(Vec_Int_t *p, int iHere, int Entry) { Vec_IntInsert(p, iHere, Entry); } +int Vec_IntFindMax_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntFindMax(p); } +int Vec_IntArgMax_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntArgMax(p); } +int Vec_IntFindMin_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntFindMin(p); } +int Vec_IntArgMin_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntArgMin(p); } +void Vec_IntReverseOrder_imctk_abc_sys(Vec_Int_t *p) { Vec_IntReverseOrder(p); } +void Vec_IntRemoveOdd_imctk_abc_sys(Vec_Int_t *p) { Vec_IntRemoveOdd(p); } +void Vec_IntRemoveEven_imctk_abc_sys(Vec_Int_t *p) { Vec_IntRemoveEven(p); } +Vec_Int_t * Vec_IntInvert_imctk_abc_sys(Vec_Int_t *p, int Fill) { return Vec_IntInvert(p, Fill); } +Vec_Int_t * Vec_IntCondense_imctk_abc_sys(Vec_Int_t *p, int Fill) { return Vec_IntCondense(p, Fill); } +int Vec_IntSum_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntSum(p); } +int Vec_IntCountEntry_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntCountEntry(p, Entry); } +int Vec_IntCountLarger_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntCountLarger(p, Entry); } +int Vec_IntCountSmaller_imctk_abc_sys(Vec_Int_t *p, int Entry) { return Vec_IntCountSmaller(p, Entry); } +int Vec_IntCountPositive_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCountPositive(p); } +int Vec_IntCountZero_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCountZero(p); } +int Vec_IntAddPositive_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntAddPositive(p); } +int Vec_IntEqual_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_IntEqual(p1, p2); } +int Vec_IntContained_imctk_abc_sys(Vec_Int_t *pSmall, Vec_Int_t *pLarge) { return Vec_IntContained(pSmall, pLarge); } +int Vec_IntCountCommon_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_IntCountCommon(p1, p2); } +int Vec_IntSortCompare1_imctk_abc_sys(int *pp1, int *pp2) { return Vec_IntSortCompare1(pp1, pp2); } +int Vec_IntSortCompare2_imctk_abc_sys(int *pp1, int *pp2) { return Vec_IntSortCompare2(pp1, pp2); } +void Vec_IntSort_imctk_abc_sys(Vec_Int_t *p, int fReverse) { Vec_IntSort(p, fReverse); } +void Vec_IntSortMulti_imctk_abc_sys(Vec_Int_t *p, int nMulti, int fReverse) { Vec_IntSortMulti(p, nMulti, fReverse); } +int Vec_IntIsSorted_imctk_abc_sys(Vec_Int_t *p, int fReverse) { return Vec_IntIsSorted(p, fReverse); } +int Vec_IntUniqify_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntUniqify(p); } +int Vec_IntCountDuplicates_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCountDuplicates(p); } +int Vec_IntCheckUniqueSmall_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCheckUniqueSmall(p); } +int Vec_IntCountUnique_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntCountUnique(p); } +int Vec_IntUniqifyPairs_imctk_abc_sys(Vec_Int_t *p) { return Vec_IntUniqifyPairs(p); } +unsigned int Vec_IntUniqueHashKeyDebug_imctk_abc_sys(unsigned char *pStr, int nChars, int TableMask) { return Vec_IntUniqueHashKeyDebug(pStr, nChars, TableMask); } +void Vec_IntUniqueProfile_imctk_abc_sys(Vec_Int_t *vData, int *pTable, int *pNexts, int TableMask, int nIntSize) { Vec_IntUniqueProfile(vData, pTable, pNexts, TableMask, nIntSize); } +unsigned int Vec_IntUniqueHashKey2_imctk_abc_sys(unsigned char *pStr, int nChars) { return Vec_IntUniqueHashKey2(pStr, nChars); } +unsigned int Vec_IntUniqueHashKey_imctk_abc_sys(unsigned char *pStr, int nChars) { return Vec_IntUniqueHashKey(pStr, nChars); } +int * Vec_IntUniqueLookup_imctk_abc_sys(Vec_Int_t *vData, int i, int nIntSize, int *pNexts, int *pStart) { return Vec_IntUniqueLookup(vData, i, nIntSize, pNexts, pStart); } +int Vec_IntUniqueCount_imctk_abc_sys(Vec_Int_t *vData, int nIntSize, Vec_Int_t **pvMap) { return Vec_IntUniqueCount(vData, nIntSize, pvMap); } +Vec_Int_t * Vec_IntUniqifyHash_imctk_abc_sys(Vec_Int_t *vData, int nIntSize) { return Vec_IntUniqifyHash(vData, nIntSize); } +int Vec_IntSortCompareUnsigned_imctk_abc_sys(unsigned int *pp1, unsigned int *pp2) { return Vec_IntSortCompareUnsigned(pp1, pp2); } +void Vec_IntSortUnsigned_imctk_abc_sys(Vec_Int_t *p) { Vec_IntSortUnsigned(p); } +int Vec_IntTwoCountCommon_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2) { return Vec_IntTwoCountCommon(vArr1, vArr2); } +int Vec_IntTwoFindCommon_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr) { return Vec_IntTwoFindCommon(vArr1, vArr2, vArr); } +int Vec_IntTwoFindCommonReverse_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr) { return Vec_IntTwoFindCommonReverse(vArr1, vArr2, vArr); } +int Vec_IntTwoRemoveCommon_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr) { return Vec_IntTwoRemoveCommon(vArr1, vArr2, vArr); } +int Vec_IntTwoRemove_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2) { return Vec_IntTwoRemove(vArr1, vArr2); } +void Vec_IntTwoMerge1_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2) { Vec_IntTwoMerge1(vArr1, vArr2); } +void Vec_IntTwoRemove1_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2) { Vec_IntTwoRemove1(vArr1, vArr2); } +void Vec_IntTwoMerge2Int_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr) { Vec_IntTwoMerge2Int(vArr1, vArr2, vArr); } +Vec_Int_t * Vec_IntTwoMerge_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2) { return Vec_IntTwoMerge(vArr1, vArr2); } +void Vec_IntTwoMerge2_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr) { Vec_IntTwoMerge2(vArr1, vArr2, vArr); } +void Vec_IntTwoSplit_imctk_abc_sys(Vec_Int_t *vArr1, Vec_Int_t *vArr2, Vec_Int_t *vArr, Vec_Int_t *vArr1n, Vec_Int_t *vArr2n) { Vec_IntTwoSplit(vArr1, vArr2, vArr, vArr1n, vArr2n); } +void Vec_IntSelectSort_imctk_abc_sys(int *pArray, int nSize) { Vec_IntSelectSort(pArray, nSize); } +void Vec_IntSelectSortReverse_imctk_abc_sys(int *pArray, int nSize) { Vec_IntSelectSortReverse(pArray, nSize); } +void Vec_IntSelectSortCost_imctk_abc_sys(int *pArray, int nSize, Vec_Int_t *vCosts) { Vec_IntSelectSortCost(pArray, nSize, vCosts); } +void Vec_IntSelectSortCostReverse_imctk_abc_sys(int *pArray, int nSize, Vec_Int_t *vCosts) { Vec_IntSelectSortCostReverse(pArray, nSize, vCosts); } +void Vec_IntSelectSortCost2_imctk_abc_sys(int *pArray, int nSize, int *pCosts) { Vec_IntSelectSortCost2(pArray, nSize, pCosts); } +void Vec_IntSelectSortCost2Reverse_imctk_abc_sys(int *pArray, int nSize, int *pCosts) { Vec_IntSelectSortCost2Reverse(pArray, nSize, pCosts); } +void Vec_IntPrint_imctk_abc_sys(Vec_Int_t *vVec) { Vec_IntPrint(vVec); } +void Vec_IntPrintBinary_imctk_abc_sys(Vec_Int_t *vVec) { Vec_IntPrintBinary(vVec); } +int Vec_IntCompareVec_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_IntCompareVec(p1, p2); } +void Vec_IntClearAppend_imctk_abc_sys(Vec_Int_t *vVec1, Vec_Int_t *vVec2) { Vec_IntClearAppend(vVec1, vVec2); } +void Vec_IntAppend_imctk_abc_sys(Vec_Int_t *vVec1, Vec_Int_t *vVec2) { Vec_IntAppend(vVec1, vVec2); } +void Vec_IntAppendSkip_imctk_abc_sys(Vec_Int_t *vVec1, Vec_Int_t *vVec2, int iVar) { Vec_IntAppendSkip(vVec1, vVec2, iVar); } +void Vec_IntAppendMinus_imctk_abc_sys(Vec_Int_t *vVec1, Vec_Int_t *vVec2, int fMinus) { Vec_IntAppendMinus(vVec1, vVec2, fMinus); } +void Vec_IntRemapArray_imctk_abc_sys(Vec_Int_t *vOld2New, Vec_Int_t *vOld, Vec_Int_t *vNew, int nNew) { Vec_IntRemapArray(vOld2New, vOld, vNew, nNew); } +void Vec_IntDumpBin_imctk_abc_sys(char *pFileName, Vec_Int_t *p, int fVerbose) { Vec_IntDumpBin(pFileName, p, fVerbose); } +Vec_Int_t * Vec_IntReadBin_imctk_abc_sys(char *pFileName, int fVerbose) { return Vec_IntReadBin(pFileName, fVerbose); } +Vec_Flt_t * Vec_FltAlloc_imctk_abc_sys(int nCap) { return Vec_FltAlloc(nCap); } +Vec_Flt_t * Vec_FltAllocExact_imctk_abc_sys(int nCap) { return Vec_FltAllocExact(nCap); } +Vec_Flt_t * Vec_FltStart_imctk_abc_sys(int nSize) { return Vec_FltStart(nSize); } +Vec_Flt_t * Vec_FltStartFull_imctk_abc_sys(int nSize) { return Vec_FltStartFull(nSize); } +Vec_Flt_t * Vec_FltAllocArray_imctk_abc_sys(float *pArray, int nSize) { return Vec_FltAllocArray(pArray, nSize); } +Vec_Flt_t * Vec_FltAllocArrayCopy_imctk_abc_sys(float *pArray, int nSize) { return Vec_FltAllocArrayCopy(pArray, nSize); } +Vec_Flt_t * Vec_FltDup_imctk_abc_sys(Vec_Flt_t *pVec) { return Vec_FltDup(pVec); } +Vec_Flt_t * Vec_FltDupArray_imctk_abc_sys(Vec_Flt_t *pVec) { return Vec_FltDupArray(pVec); } +void Vec_FltZero_imctk_abc_sys(Vec_Flt_t *p) { Vec_FltZero(p); } +void Vec_FltErase_imctk_abc_sys(Vec_Flt_t *p) { Vec_FltErase(p); } +void Vec_FltFree_imctk_abc_sys(Vec_Flt_t *p) { Vec_FltFree(p); } +void Vec_FltFreeP_imctk_abc_sys(Vec_Flt_t **p) { Vec_FltFreeP(p); } +float * Vec_FltReleaseArray_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltReleaseArray(p); } +float * Vec_FltArray_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltArray(p); } +float ** Vec_FltArrayP_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltArrayP(p); } +int Vec_FltSize_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltSize(p); } +int Vec_FltCap_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltCap(p); } +double Vec_FltMemory_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltMemory(p); } +float Vec_FltEntry_imctk_abc_sys(Vec_Flt_t *p, int i) { return Vec_FltEntry(p, i); } +float * Vec_FltEntryP_imctk_abc_sys(Vec_Flt_t *p, int i) { return Vec_FltEntryP(p, i); } +void Vec_FltWriteEntry_imctk_abc_sys(Vec_Flt_t *p, int i, float Entry) { Vec_FltWriteEntry(p, i, Entry); } +void Vec_FltAddToEntry_imctk_abc_sys(Vec_Flt_t *p, int i, float Addition) { Vec_FltAddToEntry(p, i, Addition); } +void Vec_FltUpdateEntry_imctk_abc_sys(Vec_Flt_t *p, int i, float Value) { Vec_FltUpdateEntry(p, i, Value); } +float Vec_FltEntryLast_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltEntryLast(p); } +void Vec_FltGrow_imctk_abc_sys(Vec_Flt_t *p, int nCapMin) { Vec_FltGrow(p, nCapMin); } +void Vec_FltFill_imctk_abc_sys(Vec_Flt_t *p, int nSize, float Entry) { Vec_FltFill(p, nSize, Entry); } +void Vec_FltFillExtra_imctk_abc_sys(Vec_Flt_t *p, int nSize, float Fill) { Vec_FltFillExtra(p, nSize, Fill); } +void Vec_FltShrink_imctk_abc_sys(Vec_Flt_t *p, int nSizeNew) { Vec_FltShrink(p, nSizeNew); } +void Vec_FltClear_imctk_abc_sys(Vec_Flt_t *p) { Vec_FltClear(p); } +void Vec_FltPush_imctk_abc_sys(Vec_Flt_t *p, float Entry) { Vec_FltPush(p, Entry); } +void Vec_FltPushOrder_imctk_abc_sys(Vec_Flt_t *p, float Entry) { Vec_FltPushOrder(p, Entry); } +int Vec_FltPushUnique_imctk_abc_sys(Vec_Flt_t *p, float Entry) { return Vec_FltPushUnique(p, Entry); } +float Vec_FltPop_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltPop(p); } +int Vec_FltFind_imctk_abc_sys(Vec_Flt_t *p, float Entry) { return Vec_FltFind(p, Entry); } +int Vec_FltRemove_imctk_abc_sys(Vec_Flt_t *p, float Entry) { return Vec_FltRemove(p, Entry); } +float Vec_FltFindMax_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltFindMax(p); } +float Vec_FltFindMin_imctk_abc_sys(Vec_Flt_t *p) { return Vec_FltFindMin(p); } +int Vec_FltEqual_imctk_abc_sys(Vec_Flt_t *p1, Vec_Flt_t *p2) { return Vec_FltEqual(p1, p2); } +void Vec_FltPrint_imctk_abc_sys(Vec_Flt_t *vVec) { Vec_FltPrint(vVec); } +int Vec_FltSortCompare1_imctk_abc_sys(float *pp1, float *pp2) { return Vec_FltSortCompare1(pp1, pp2); } +int Vec_FltSortCompare2_imctk_abc_sys(float *pp1, float *pp2) { return Vec_FltSortCompare2(pp1, pp2); } +void Vec_FltSort_imctk_abc_sys(Vec_Flt_t *p, int fReverse) { Vec_FltSort(p, fReverse); } +Vec_Str_t * Vec_StrAlloc_imctk_abc_sys(int nCap) { return Vec_StrAlloc(nCap); } +Vec_Str_t * Vec_StrAllocExact_imctk_abc_sys(int nCap) { return Vec_StrAllocExact(nCap); } +Vec_Str_t * Vec_StrStart_imctk_abc_sys(int nSize) { return Vec_StrStart(nSize); } +Vec_Str_t * Vec_StrAllocArray_imctk_abc_sys(char *pArray, int nSize) { return Vec_StrAllocArray(pArray, nSize); } +Vec_Str_t * Vec_StrAllocArrayCopy_imctk_abc_sys(char *pArray, int nSize) { return Vec_StrAllocArrayCopy(pArray, nSize); } +Vec_Str_t * Vec_StrDup_imctk_abc_sys(Vec_Str_t *pVec) { return Vec_StrDup(pVec); } +Vec_Str_t * Vec_StrDupArray_imctk_abc_sys(Vec_Str_t *pVec) { return Vec_StrDupArray(pVec); } +void Vec_StrZero_imctk_abc_sys(Vec_Str_t *p) { Vec_StrZero(p); } +void Vec_StrErase_imctk_abc_sys(Vec_Str_t *p) { Vec_StrErase(p); } +void Vec_StrFree_imctk_abc_sys(Vec_Str_t *p) { Vec_StrFree(p); } +void Vec_StrFreeP_imctk_abc_sys(Vec_Str_t **p) { Vec_StrFreeP(p); } +char * Vec_StrReleaseArray_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrReleaseArray(p); } +char * Vec_StrArray_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrArray(p); } +char * Vec_StrLimit_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrLimit(p); } +int Vec_StrSize_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrSize(p); } +void Vec_StrSetSize_imctk_abc_sys(Vec_Str_t *p, int nSize) { Vec_StrSetSize(p, nSize); } +int Vec_StrCap_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrCap(p); } +double Vec_StrMemory_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrMemory(p); } +char Vec_StrEntry_imctk_abc_sys(Vec_Str_t *p, int i) { return Vec_StrEntry(p, i); } +char * Vec_StrEntryP_imctk_abc_sys(Vec_Str_t *p, int i) { return Vec_StrEntryP(p, i); } +void Vec_StrWriteEntry_imctk_abc_sys(Vec_Str_t *p, int i, char Entry) { Vec_StrWriteEntry(p, i, Entry); } +char Vec_StrEntryLast_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrEntryLast(p); } +void Vec_StrGrow_imctk_abc_sys(Vec_Str_t *p, int nCapMin) { Vec_StrGrow(p, nCapMin); } +void Vec_StrFill_imctk_abc_sys(Vec_Str_t *p, int nSize, char Fill) { Vec_StrFill(p, nSize, Fill); } +void Vec_StrFillExtra_imctk_abc_sys(Vec_Str_t *p, int nSize, char Fill) { Vec_StrFillExtra(p, nSize, Fill); } +char Vec_StrGetEntry_imctk_abc_sys(Vec_Str_t *p, int i) { return Vec_StrGetEntry(p, i); } +void Vec_StrSetEntry_imctk_abc_sys(Vec_Str_t *p, int i, char Entry) { Vec_StrSetEntry(p, i, Entry); } +void Vec_StrShrink_imctk_abc_sys(Vec_Str_t *p, int nSizeNew) { Vec_StrShrink(p, nSizeNew); } +void Vec_StrClear_imctk_abc_sys(Vec_Str_t *p) { Vec_StrClear(p); } +void Vec_StrPush_imctk_abc_sys(Vec_Str_t *p, char Entry) { Vec_StrPush(p, Entry); } +void Vec_StrPushTwo_imctk_abc_sys(Vec_Str_t *p, char Entry1, char Entry2) { Vec_StrPushTwo(p, Entry1, Entry2); } +void Vec_StrPushBuffer_imctk_abc_sys(Vec_Str_t *p, char *pBuffer, int nSize) { Vec_StrPushBuffer(p, pBuffer, nSize); } +char Vec_StrPop_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrPop(p); } +void Vec_StrIntPrint_imctk_abc_sys(Vec_Str_t *p) { Vec_StrIntPrint(p); } +void Vec_StrPrintNum_imctk_abc_sys(Vec_Str_t *p, int Num) { Vec_StrPrintNum(p, Num); } +void Vec_StrPrintNumStar_imctk_abc_sys(Vec_Str_t *p, int Num, int nDigits) { Vec_StrPrintNumStar(p, Num, nDigits); } +void Vec_StrPrintStr_imctk_abc_sys(Vec_Str_t *p, const char *pStr) { Vec_StrPrintStr(p, pStr); } +void Vec_StrAppend_imctk_abc_sys(Vec_Str_t *p, const char *pString) { Vec_StrAppend(p, pString); } +void Vec_StrCopy_imctk_abc_sys(Vec_Str_t *p, const char *pString) { Vec_StrCopy(p, pString); } +void Vec_StrReverseOrder_imctk_abc_sys(Vec_Str_t *p) { Vec_StrReverseOrder(p); } +int Vec_StrSum_imctk_abc_sys(Vec_Str_t *p) { return Vec_StrSum(p); } +int Vec_StrCountEntry_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountEntry(p, Entry); } +int Vec_StrCountLarger_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountLarger(p, Entry); } +int Vec_StrCountSmaller_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountSmaller(p, Entry); } +int Vec_StrCountEntryLit_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountEntryLit(p, Entry); } +int Vec_StrCountLargerLit_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountLargerLit(p, Entry); } +int Vec_StrCountSmallerLit_imctk_abc_sys(Vec_Str_t *p, char Entry) { return Vec_StrCountSmallerLit(p, Entry); } +int Vec_StrEqual_imctk_abc_sys(Vec_Str_t *p1, Vec_Str_t *p2) { return Vec_StrEqual(p1, p2); } +int Vec_StrSortCompare1_imctk_abc_sys(char *pp1, char *pp2) { return Vec_StrSortCompare1(pp1, pp2); } +int Vec_StrSortCompare2_imctk_abc_sys(char *pp1, char *pp2) { return Vec_StrSortCompare2(pp1, pp2); } +void Vec_StrSort_imctk_abc_sys(Vec_Str_t *p, int fReverse) { Vec_StrSort(p, fReverse); } +int Vec_StrCompareVec_imctk_abc_sys(Vec_Str_t *p1, Vec_Str_t *p2) { return Vec_StrCompareVec(p1, p2); } +void Vec_StrPutI_ne_imctk_abc_sys(Vec_Str_t *vOut, int Val) { Vec_StrPutI_ne(vOut, Val); } +int Vec_StrGetI_ne_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetI_ne(vOut, pPos); } +void Vec_StrPutI_imctk_abc_sys(Vec_Str_t *vOut, int Val) { Vec_StrPutI(vOut, Val); } +int Vec_StrGetI_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetI(vOut, pPos); } +void Vec_StrPutW_imctk_abc_sys(Vec_Str_t *vOut, word Val) { Vec_StrPutW(vOut, Val); } +word Vec_StrGetW_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetW(vOut, pPos); } +void Vec_StrPutF_imctk_abc_sys(Vec_Str_t *vOut, float Val) { Vec_StrPutF(vOut, Val); } +float Vec_StrGetF_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetF(vOut, pPos); } +void Vec_StrPutD_imctk_abc_sys(Vec_Str_t *vOut, double Val) { Vec_StrPutD(vOut, Val); } +double Vec_StrGetD_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetD(vOut, pPos); } +void Vec_StrPutS_imctk_abc_sys(Vec_Str_t *vOut, char *pStr) { Vec_StrPutS(vOut, pStr); } +char * Vec_StrGetS_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetS(vOut, pPos); } +void Vec_StrPutC_imctk_abc_sys(Vec_Str_t *vOut, char c) { Vec_StrPutC(vOut, c); } +char Vec_StrGetC_imctk_abc_sys(Vec_Str_t *vOut, int *pPos) { return Vec_StrGetC(vOut, pPos); } +Vec_Ptr_t * Vec_PtrAlloc_imctk_abc_sys(int nCap) { return Vec_PtrAlloc(nCap); } +Vec_Ptr_t * Vec_PtrAllocExact_imctk_abc_sys(int nCap) { return Vec_PtrAllocExact(nCap); } +Vec_Ptr_t * Vec_PtrStart_imctk_abc_sys(int nSize) { return Vec_PtrStart(nSize); } +Vec_Ptr_t * Vec_PtrAllocArray_imctk_abc_sys(void **pArray, int nSize) { return Vec_PtrAllocArray(pArray, nSize); } +Vec_Ptr_t * Vec_PtrAllocArrayCopy_imctk_abc_sys(void **pArray, int nSize) { return Vec_PtrAllocArrayCopy(pArray, nSize); } +Vec_Ptr_t * Vec_PtrDup_imctk_abc_sys(Vec_Ptr_t *pVec) { return Vec_PtrDup(pVec); } +Vec_Ptr_t * Vec_PtrDupStr_imctk_abc_sys(Vec_Ptr_t *pVec) { return Vec_PtrDupStr(pVec); } +Vec_Ptr_t * Vec_PtrDupArray_imctk_abc_sys(Vec_Ptr_t *pVec) { return Vec_PtrDupArray(pVec); } +void Vec_PtrZero_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrZero(p); } +void Vec_PtrErase_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrErase(p); } +void Vec_PtrFree_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrFree(p); } +void Vec_PtrFreeP_imctk_abc_sys(Vec_Ptr_t **p) { Vec_PtrFreeP(p); } +void ** Vec_PtrReleaseArray_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrReleaseArray(p); } +void ** Vec_PtrArray_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrArray(p); } +int Vec_PtrSize_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrSize(p); } +int Vec_PtrCap_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrCap(p); } +double Vec_PtrMemory_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrMemory(p); } +int Vec_PtrCountZero_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrCountZero(p); } +void * Vec_PtrEntry_imctk_abc_sys(Vec_Ptr_t *p, int i) { return Vec_PtrEntry(p, i); } +void ** Vec_PtrEntryP_imctk_abc_sys(Vec_Ptr_t *p, int i) { return Vec_PtrEntryP(p, i); } +void Vec_PtrWriteEntry_imctk_abc_sys(Vec_Ptr_t *p, int i, void *Entry) { Vec_PtrWriteEntry(p, i, Entry); } +void * Vec_PtrEntryLast_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrEntryLast(p); } +void Vec_PtrGrow_imctk_abc_sys(Vec_Ptr_t *p, int nCapMin) { Vec_PtrGrow(p, nCapMin); } +void Vec_PtrFill_imctk_abc_sys(Vec_Ptr_t *p, int nSize, void *Entry) { Vec_PtrFill(p, nSize, Entry); } +void Vec_PtrFillTwo_imctk_abc_sys(Vec_Ptr_t *p, int nSize, void *EntryEven, void *EntryOdd) { Vec_PtrFillTwo(p, nSize, EntryEven, EntryOdd); } +void Vec_PtrFillExtra_imctk_abc_sys(Vec_Ptr_t *p, int nSize, void *Fill) { Vec_PtrFillExtra(p, nSize, Fill); } +void * Vec_PtrGetEntry_imctk_abc_sys(Vec_Ptr_t *p, int i) { return Vec_PtrGetEntry(p, i); } +void Vec_PtrSetEntry_imctk_abc_sys(Vec_Ptr_t *p, int i, void *Entry) { Vec_PtrSetEntry(p, i, Entry); } +void Vec_PtrShrink_imctk_abc_sys(Vec_Ptr_t *p, int nSizeNew) { Vec_PtrShrink(p, nSizeNew); } +void Vec_PtrClear_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrClear(p); } +void Vec_PtrFreeData_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrFreeData(p); } +void Vec_PtrFreeFree_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrFreeFree(p); } +void Vec_PtrFreeFunc_imctk_abc_sys(Vec_Ptr_t *p, void (*pFuncItemFree) (void *)) { Vec_PtrFreeFunc(p, pFuncItemFree); } +void Vec_PtrCopy_imctk_abc_sys(Vec_Ptr_t *pDest, Vec_Ptr_t *pSour) { Vec_PtrCopy(pDest, pSour); } +void Vec_PtrPrintNames_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrPrintNames(p); } +void Vec_PtrPush_imctk_abc_sys(Vec_Ptr_t *p, void *Entry) { Vec_PtrPush(p, Entry); } +void Vec_PtrPushTwo_imctk_abc_sys(Vec_Ptr_t *p, void *Entry1, void *Entry2) { Vec_PtrPushTwo(p, Entry1, Entry2); } +void Vec_PtrAppend_imctk_abc_sys(Vec_Ptr_t *vVec1, Vec_Ptr_t *vVec2) { Vec_PtrAppend(vVec1, vVec2); } +void Vec_PtrPushFirst_imctk_abc_sys(Vec_Ptr_t *p, void *Entry) { Vec_PtrPushFirst(p, Entry); } +int Vec_PtrPushUnique_imctk_abc_sys(Vec_Ptr_t *p, void *Entry) { return Vec_PtrPushUnique(p, Entry); } +void * Vec_PtrPop_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrPop(p); } +int Vec_PtrFind_imctk_abc_sys(Vec_Ptr_t *p, void *Entry) { return Vec_PtrFind(p, Entry); } +int Vec_PtrFindStr_imctk_abc_sys(Vec_Ptr_t *p, char *Entry) { return Vec_PtrFindStr(p, Entry); } +void Vec_PtrRemove_imctk_abc_sys(Vec_Ptr_t *p, void *Entry) { Vec_PtrRemove(p, Entry); } +void Vec_PtrDrop_imctk_abc_sys(Vec_Ptr_t *p, int i) { Vec_PtrDrop(p, i); } +void Vec_PtrInsert_imctk_abc_sys(Vec_Ptr_t *p, int iHere, void *Entry) { Vec_PtrInsert(p, iHere, Entry); } +void Vec_PtrReorder_imctk_abc_sys(Vec_Ptr_t *p, int nItems) { Vec_PtrReorder(p, nItems); } +void Vec_PtrReverseOrder_imctk_abc_sys(Vec_Ptr_t *p) { Vec_PtrReverseOrder(p); } +int Vec_PtrEqual_imctk_abc_sys(Vec_Ptr_t *p1, Vec_Ptr_t *p2) { return Vec_PtrEqual(p1, p2); } +int Vec_PtrSortComparePtr_imctk_abc_sys(void **pp1, void **pp2) { return Vec_PtrSortComparePtr(pp1, pp2); } +void Vec_PtrSort_imctk_abc_sys(Vec_Ptr_t *p, int (*Vec_PtrSortCompare) (const void *, const void *)) { Vec_PtrSort(p, Vec_PtrSortCompare); } +void Vec_PtrUniqify_imctk_abc_sys(Vec_Ptr_t *p, int (*Vec_PtrSortCompare) (const void *, const void *)) { Vec_PtrUniqify(p, Vec_PtrSortCompare); } +void Vec_PtrUniqify2_imctk_abc_sys(Vec_Ptr_t *p, int (*Vec_PtrSortCompare) (const void *, const void *), void (*Vec_PtrObjFree) (void *), Vec_Int_t *vCounts) { Vec_PtrUniqify2(p, Vec_PtrSortCompare, Vec_PtrObjFree, vCounts); } +Vec_Ptr_t * Vec_PtrAllocSimInfo_imctk_abc_sys(int nEntries, int nWords) { return Vec_PtrAllocSimInfo(nEntries, nWords); } +int Vec_PtrReadWordsSimInfo_imctk_abc_sys(Vec_Ptr_t *p) { return Vec_PtrReadWordsSimInfo(p); } +void Vec_PtrCleanSimInfo_imctk_abc_sys(Vec_Ptr_t *vInfo, int iWord, int nWords) { Vec_PtrCleanSimInfo(vInfo, iWord, nWords); } +void Vec_PtrFillSimInfo_imctk_abc_sys(Vec_Ptr_t *vInfo, int iWord, int nWords) { Vec_PtrFillSimInfo(vInfo, iWord, nWords); } +void Vec_PtrDoubleSimInfo_imctk_abc_sys(Vec_Ptr_t *vInfo) { Vec_PtrDoubleSimInfo(vInfo); } +void Vec_PtrReallocSimInfo_imctk_abc_sys(Vec_Ptr_t *vInfo) { Vec_PtrReallocSimInfo(vInfo); } +Vec_Ptr_t * Vec_PtrAllocTruthTables_imctk_abc_sys(int nVars) { return Vec_PtrAllocTruthTables(nVars); } +Vec_Vec_t * Vec_VecAlloc_imctk_abc_sys(int nCap) { return Vec_VecAlloc(nCap); } +Vec_Vec_t * Vec_VecStart_imctk_abc_sys(int nSize) { return Vec_VecStart(nSize); } +void Vec_VecExpand_imctk_abc_sys(Vec_Vec_t *p, int Level) { Vec_VecExpand(p, Level); } +void Vec_VecExpandInt_imctk_abc_sys(Vec_Vec_t *p, int Level) { Vec_VecExpandInt(p, Level); } +int Vec_VecSize_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecSize(p); } +int Vec_VecCap_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecCap(p); } +int Vec_VecLevelSize_imctk_abc_sys(Vec_Vec_t *p, int i) { return Vec_VecLevelSize(p, i); } +Vec_Ptr_t * Vec_VecEntry_imctk_abc_sys(Vec_Vec_t *p, int i) { return Vec_VecEntry(p, i); } +Vec_Int_t * Vec_VecEntryInt_imctk_abc_sys(Vec_Vec_t *p, int i) { return Vec_VecEntryInt(p, i); } +double Vec_VecMemory_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecMemory(p); } +double Vec_VecMemoryInt_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecMemoryInt(p); } +void * Vec_VecEntryEntry_imctk_abc_sys(Vec_Vec_t *p, int i, int k) { return Vec_VecEntryEntry(p, i, k); } +int Vec_VecEntryEntryInt_imctk_abc_sys(Vec_Vec_t *p, int i, int k) { return Vec_VecEntryEntryInt(p, i, k); } +void Vec_VecFree_imctk_abc_sys(Vec_Vec_t *p) { Vec_VecFree(p); } +void Vec_VecErase_imctk_abc_sys(Vec_Vec_t *p) { Vec_VecErase(p); } +void Vec_VecFreeP_imctk_abc_sys(Vec_Vec_t **p) { Vec_VecFreeP(p); } +Vec_Vec_t * Vec_VecDup_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecDup(p); } +Vec_Vec_t * Vec_VecDupInt_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecDupInt(p); } +int Vec_VecSizeSize_imctk_abc_sys(Vec_Vec_t *p) { return Vec_VecSizeSize(p); } +void Vec_VecClear_imctk_abc_sys(Vec_Vec_t *p) { Vec_VecClear(p); } +void Vec_VecPush_imctk_abc_sys(Vec_Vec_t *p, int Level, void *Entry) { Vec_VecPush(p, Level, Entry); } +void Vec_VecPushInt_imctk_abc_sys(Vec_Vec_t *p, int Level, int Entry) { Vec_VecPushInt(p, Level, Entry); } +void Vec_VecPushUnique_imctk_abc_sys(Vec_Vec_t *p, int Level, void *Entry) { Vec_VecPushUnique(p, Level, Entry); } +void Vec_VecPushUniqueInt_imctk_abc_sys(Vec_Vec_t *p, int Level, int Entry) { Vec_VecPushUniqueInt(p, Level, Entry); } +int Vec_VecSortCompare1_imctk_abc_sys(Vec_Ptr_t **pp1, Vec_Ptr_t **pp2) { return Vec_VecSortCompare1(pp1, pp2); } +int Vec_VecSortCompare2_imctk_abc_sys(Vec_Ptr_t **pp1, Vec_Ptr_t **pp2) { return Vec_VecSortCompare2(pp1, pp2); } +void Vec_VecSort_imctk_abc_sys(Vec_Vec_t *p, int fReverse) { Vec_VecSort(p, fReverse); } +int Vec_VecSortCompare3_imctk_abc_sys(Vec_Int_t **pp1, Vec_Int_t **pp2) { return Vec_VecSortCompare3(pp1, pp2); } +int Vec_VecSortCompare4_imctk_abc_sys(Vec_Int_t **pp1, Vec_Int_t **pp2) { return Vec_VecSortCompare4(pp1, pp2); } +void Vec_VecSortByFirstInt_imctk_abc_sys(Vec_Vec_t *p, int fReverse) { Vec_VecSortByFirstInt(p, fReverse); } +void Vec_VecPrintInt_imctk_abc_sys(Vec_Vec_t *p, int fSkipSingles) { Vec_VecPrintInt(p, fSkipSingles); } +Vec_Att_t * Vec_AttAlloc_imctk_abc_sys(int nSize, void *pMan, void (*pFuncFreeMan) (void *), void * (*pFuncStartObj) (void *), void (*pFuncFreeObj) (void *, void *)) { return Vec_AttAlloc(nSize, pMan, pFuncFreeMan, pFuncStartObj, pFuncFreeObj); } +void * Vec_AttFree_imctk_abc_sys(Vec_Att_t *p, int fFreeMan) { return Vec_AttFree(p, fFreeMan); } +void Vec_AttClear_imctk_abc_sys(Vec_Att_t *p) { Vec_AttClear(p); } +void Vec_AttFreeEntry_imctk_abc_sys(Vec_Att_t *p, int i) { Vec_AttFreeEntry(p, i); } +void Vec_AttGrow_imctk_abc_sys(Vec_Att_t *p, int nCapMin) { Vec_AttGrow(p, nCapMin); } +void Vec_AttWriteEntry_imctk_abc_sys(Vec_Att_t *p, int i, void *pEntry) { Vec_AttWriteEntry(p, i, pEntry); } +void * Vec_AttEntry_imctk_abc_sys(Vec_Att_t *p, int i) { return Vec_AttEntry(p, i); } +void * Vec_AttMan_imctk_abc_sys(Vec_Att_t *p) { return Vec_AttMan(p); } +void ** Vec_AttArray_imctk_abc_sys(Vec_Att_t *p) { return Vec_AttArray(p); } +Vec_Wrd_t * Vec_WrdAlloc_imctk_abc_sys(int nCap) { return Vec_WrdAlloc(nCap); } +Vec_Wrd_t * Vec_WrdAllocExact_imctk_abc_sys(int nCap) { return Vec_WrdAllocExact(nCap); } +Vec_Wrd_t * Vec_WrdStart_imctk_abc_sys(int nSize) { return Vec_WrdStart(nSize); } +Vec_Wrd_t * Vec_WrdStartFull_imctk_abc_sys(int nSize) { return Vec_WrdStartFull(nSize); } +Vec_Wrd_t * Vec_WrdStartNatural_imctk_abc_sys(int nSize) { return Vec_WrdStartNatural(nSize); } +Vec_Wrd_t * Vec_WrdStartRandom_imctk_abc_sys(int nSize) { return Vec_WrdStartRandom(nSize); } +Vec_Wrd_t * Vec_WrdStartTruthTables_imctk_abc_sys(int nVars) { return Vec_WrdStartTruthTables(nVars); } +Vec_Wrd_t * Vec_WrdStartTruthTablesRev_imctk_abc_sys(int nVars) { return Vec_WrdStartTruthTablesRev(nVars); } +int Vec_WrdShiftOne_imctk_abc_sys(Vec_Wrd_t *p, int nWords) { return Vec_WrdShiftOne(p, nWords); } +Vec_Wrd_t * Vec_WrdAllocArray_imctk_abc_sys(word *pArray, int nSize) { return Vec_WrdAllocArray(pArray, nSize); } +Vec_Wrd_t * Vec_WrdAllocArrayCopy_imctk_abc_sys(word *pArray, int nSize) { return Vec_WrdAllocArrayCopy(pArray, nSize); } +Vec_Wrd_t * Vec_WrdDup_imctk_abc_sys(Vec_Wrd_t *pVec) { return Vec_WrdDup(pVec); } +Vec_Wrd_t * Vec_WrdDupArray_imctk_abc_sys(Vec_Wrd_t *pVec) { return Vec_WrdDupArray(pVec); } +void Vec_WrdErase_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdErase(p); } +void Vec_WrdFree_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdFree(p); } +void Vec_WrdFreeP_imctk_abc_sys(Vec_Wrd_t **p) { Vec_WrdFreeP(p); } +word * Vec_WrdReleaseArray_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdReleaseArray(p); } +word * Vec_WrdArray_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdArray(p); } +word * Vec_WrdLimit_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdLimit(p); } +int Vec_WrdSize_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdSize(p); } +int Vec_WrdChangeSize_imctk_abc_sys(Vec_Wrd_t *p, int Shift) { return Vec_WrdChangeSize(p, Shift); } +int Vec_WrdCap_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdCap(p); } +double Vec_WrdMemory_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdMemory(p); } +word Vec_WrdEntry_imctk_abc_sys(Vec_Wrd_t *p, int i) { return Vec_WrdEntry(p, i); } +word * Vec_WrdEntryP_imctk_abc_sys(Vec_Wrd_t *p, int i) { return Vec_WrdEntryP(p, i); } +void Vec_WrdWriteEntry_imctk_abc_sys(Vec_Wrd_t *p, int i, word Entry) { Vec_WrdWriteEntry(p, i, Entry); } +word Vec_WrdAddToEntry_imctk_abc_sys(Vec_Wrd_t *p, int i, word Addition) { return Vec_WrdAddToEntry(p, i, Addition); } +word Vec_WrdEntryLast_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdEntryLast(p); } +void Vec_WrdGrow_imctk_abc_sys(Vec_Wrd_t *p, int nCapMin) { Vec_WrdGrow(p, nCapMin); } +void Vec_WrdFill_imctk_abc_sys(Vec_Wrd_t *p, int nSize, word Fill) { Vec_WrdFill(p, nSize, Fill); } +void Vec_WrdFillExtra_imctk_abc_sys(Vec_Wrd_t *p, int nSize, word Fill) { Vec_WrdFillExtra(p, nSize, Fill); } +word Vec_WrdGetEntry_imctk_abc_sys(Vec_Wrd_t *p, int i) { return Vec_WrdGetEntry(p, i); } +word * Vec_WrdGetEntryP_imctk_abc_sys(Vec_Wrd_t *p, int i) { return Vec_WrdGetEntryP(p, i); } +void Vec_WrdSetEntry_imctk_abc_sys(Vec_Wrd_t *p, int i, word Entry) { Vec_WrdSetEntry(p, i, Entry); } +void Vec_WrdShrink_imctk_abc_sys(Vec_Wrd_t *p, int nSizeNew) { Vec_WrdShrink(p, nSizeNew); } +void Vec_WrdClear_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdClear(p); } +void Vec_WrdPush_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { Vec_WrdPush(p, Entry); } +void Vec_WrdPushTwo_imctk_abc_sys(Vec_Wrd_t *p, word Entry1, word Entry2) { Vec_WrdPushTwo(p, Entry1, Entry2); } +void Vec_WrdPushThree_imctk_abc_sys(Vec_Wrd_t *p, word Entry1, word Entry2, word Entry3) { Vec_WrdPushThree(p, Entry1, Entry2, Entry3); } +void Vec_WrdPushFour_imctk_abc_sys(Vec_Wrd_t *p, word Entry1, word Entry2, word Entry3, word Entry4) { Vec_WrdPushFour(p, Entry1, Entry2, Entry3, Entry4); } +void Vec_WrdPushArray_imctk_abc_sys(Vec_Wrd_t *p, word *pEntries, int nEntries) { Vec_WrdPushArray(p, pEntries, nEntries); } +void Vec_WrdPushFirst_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { Vec_WrdPushFirst(p, Entry); } +void Vec_WrdPushOrder_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { Vec_WrdPushOrder(p, Entry); } +int Vec_WrdPushUniqueOrder_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { return Vec_WrdPushUniqueOrder(p, Entry); } +int Vec_WrdPushUnique_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { return Vec_WrdPushUnique(p, Entry); } +word * Vec_WrdFetch_imctk_abc_sys(Vec_Wrd_t *p, int nWords) { return Vec_WrdFetch(p, nWords); } +word Vec_WrdPop_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdPop(p); } +int Vec_WrdFind_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { return Vec_WrdFind(p, Entry); } +int Vec_WrdRemove_imctk_abc_sys(Vec_Wrd_t *p, word Entry) { return Vec_WrdRemove(p, Entry); } +void Vec_WrdInsert_imctk_abc_sys(Vec_Wrd_t *p, int iHere, word Entry) { Vec_WrdInsert(p, iHere, Entry); } +void Vec_WrdDrop_imctk_abc_sys(Vec_Wrd_t *p, int i) { Vec_WrdDrop(p, i); } +word Vec_WrdFindMax_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdFindMax(p); } +word Vec_WrdFindMin_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdFindMin(p); } +void Vec_WrdReverseOrder_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdReverseOrder(p); } +Vec_Wrd_t * Vec_WrdInvert_imctk_abc_sys(Vec_Wrd_t *p, word Fill) { return Vec_WrdInvert(p, Fill); } +word Vec_WrdSum_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdSum(p); } +int Vec_WrdCountZero_imctk_abc_sys(Vec_Wrd_t *p) { return Vec_WrdCountZero(p); } +int Vec_WrdEqual_imctk_abc_sys(Vec_Wrd_t *p1, Vec_Wrd_t *p2) { return Vec_WrdEqual(p1, p2); } +int Vec_WrdCountCommon_imctk_abc_sys(Vec_Wrd_t *p1, Vec_Wrd_t *p2) { return Vec_WrdCountCommon(p1, p2); } +int Vec_WrdSortCompare1_imctk_abc_sys(word *pp1, word *pp2) { return Vec_WrdSortCompare1(pp1, pp2); } +int Vec_WrdSortCompare2_imctk_abc_sys(word *pp1, word *pp2) { return Vec_WrdSortCompare2(pp1, pp2); } +void Vec_WrdSort_imctk_abc_sys(Vec_Wrd_t *p, int fReverse) { Vec_WrdSort(p, fReverse); } +void Vec_WrdUniqify_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdUniqify(p); } +int Vec_WrdUniqueCount_imctk_abc_sys(Vec_Wrd_t *vData, int nWordSize, Vec_Int_t **pvMap) { return Vec_WrdUniqueCount(vData, nWordSize, pvMap); } +Vec_Wrd_t * Vec_WrdUniqifyHash_imctk_abc_sys(Vec_Wrd_t *vData, int nWordSize) { return Vec_WrdUniqifyHash(vData, nWordSize); } +int Vec_WrdTwoCountCommon_imctk_abc_sys(Vec_Wrd_t *vArr1, Vec_Wrd_t *vArr2) { return Vec_WrdTwoCountCommon(vArr1, vArr2); } +int Vec_WrdSortCompareUnsigned_imctk_abc_sys(word *pp1, word *pp2) { return Vec_WrdSortCompareUnsigned(pp1, pp2); } +void Vec_WrdSortUnsigned_imctk_abc_sys(Vec_Wrd_t *p) { Vec_WrdSortUnsigned(p); } +void Vec_WrdAppend_imctk_abc_sys(Vec_Wrd_t *vVec1, Vec_Wrd_t *vVec2) { Vec_WrdAppend(vVec1, vVec2); } +void Vec_WrdDumpBoolOne_imctk_abc_sys(FILE *pFile, word *pSim, int nBits, int fReverse) { Vec_WrdDumpBoolOne(pFile, pSim, nBits, fReverse); } +void Vec_WrdDumpBool_imctk_abc_sys(char *pFileName, Vec_Wrd_t *p, int nWords, int nBits, int fReverse, int fVerbose) { Vec_WrdDumpBool(pFileName, p, nWords, nBits, fReverse, fVerbose); } +void Vec_WrdDumpHexOne_imctk_abc_sys(FILE *pFile, word *pSim, int nWords) { Vec_WrdDumpHexOne(pFile, pSim, nWords); } +void Vec_WrdPrintHex_imctk_abc_sys(Vec_Wrd_t *p, int nWords) { Vec_WrdPrintHex(p, nWords); } +void Vec_WrdDumpHex_imctk_abc_sys(char *pFileName, Vec_Wrd_t *p, int nWords, int fVerbose) { Vec_WrdDumpHex(pFileName, p, nWords, fVerbose); } +int Vec_WrdReadHexOne_imctk_abc_sys(char c) { return Vec_WrdReadHexOne(c); } +Vec_Wrd_t * Vec_WrdReadHex_imctk_abc_sys(char *pFileName, int *pnWords, int fVerbose) { return Vec_WrdReadHex(pFileName, pnWords, fVerbose); } +void Vec_WrdDumpBin_imctk_abc_sys(char *pFileName, Vec_Wrd_t *p, int fVerbose) { Vec_WrdDumpBin(pFileName, p, fVerbose); } +Vec_Wrd_t * Vec_WrdReadBin_imctk_abc_sys(char *pFileName, int fVerbose) { return Vec_WrdReadBin(pFileName, fVerbose); } +Vec_Bit_t * Vec_BitAlloc_imctk_abc_sys(int nCap) { return Vec_BitAlloc(nCap); } +Vec_Bit_t * Vec_BitStart_imctk_abc_sys(int nSize) { return Vec_BitStart(nSize); } +Vec_Bit_t * Vec_BitStartFull_imctk_abc_sys(int nSize) { return Vec_BitStartFull(nSize); } +Vec_Bit_t * Vec_BitDup_imctk_abc_sys(Vec_Bit_t *pVec) { return Vec_BitDup(pVec); } +void Vec_BitFree_imctk_abc_sys(Vec_Bit_t *p) { Vec_BitFree(p); } +void Vec_BitFreeP_imctk_abc_sys(Vec_Bit_t **p) { Vec_BitFreeP(p); } +int * Vec_BitReleaseArray_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitReleaseArray(p); } +int * Vec_BitArray_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitArray(p); } +int Vec_BitSize_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitSize(p); } +int Vec_BitCap_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitCap(p); } +double Vec_BitMemory_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitMemory(p); } +int Vec_BitEntry_imctk_abc_sys(Vec_Bit_t *p, int i) { return Vec_BitEntry(p, i); } +void Vec_BitWriteEntry_imctk_abc_sys(Vec_Bit_t *p, int i, int Entry) { Vec_BitWriteEntry(p, i, Entry); } +int Vec_BitAddEntry_imctk_abc_sys(Vec_Bit_t *p, int i) { return Vec_BitAddEntry(p, i); } +int Vec_BitEntryLast_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitEntryLast(p); } +void Vec_BitGrow_imctk_abc_sys(Vec_Bit_t *p, int nCapMin) { Vec_BitGrow(p, nCapMin); } +void Vec_BitFill_imctk_abc_sys(Vec_Bit_t *p, int nSize, int Fill) { Vec_BitFill(p, nSize, Fill); } +void Vec_BitFillExtra_imctk_abc_sys(Vec_Bit_t *p, int nSize, int Fill) { Vec_BitFillExtra(p, nSize, Fill); } +int Vec_BitGetEntry_imctk_abc_sys(Vec_Bit_t *p, int i) { return Vec_BitGetEntry(p, i); } +void Vec_BitSetEntry_imctk_abc_sys(Vec_Bit_t *p, int i, int Entry) { Vec_BitSetEntry(p, i, Entry); } +void Vec_BitShrink_imctk_abc_sys(Vec_Bit_t *p, int nSizeNew) { Vec_BitShrink(p, nSizeNew); } +void Vec_BitClear_imctk_abc_sys(Vec_Bit_t *p) { Vec_BitClear(p); } +void Vec_BitPush_imctk_abc_sys(Vec_Bit_t *p, int Entry) { Vec_BitPush(p, Entry); } +int Vec_BitPop_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitPop(p); } +int Vec_BitCountWord_imctk_abc_sys(unsigned int uWord) { return Vec_BitCountWord(uWord); } +int Vec_BitCount_imctk_abc_sys(Vec_Bit_t *p) { return Vec_BitCount(p); } +void Vec_BitReset_imctk_abc_sys(Vec_Bit_t *p) { Vec_BitReset(p); } +void Vec_BitPrint_imctk_abc_sys(Vec_Bit_t *p) { Vec_BitPrint(p); } +void Vec_MemAlloc__imctk_abc_sys(Vec_Mem_t *p, int nEntrySize, int LogPageSze) { Vec_MemAlloc_(p, nEntrySize, LogPageSze); } +Vec_Mem_t * Vec_MemAlloc_imctk_abc_sys(int nEntrySize, int LogPageSze) { return Vec_MemAlloc(nEntrySize, LogPageSze); } +void Vec_MemFree_imctk_abc_sys(Vec_Mem_t *p) { Vec_MemFree(p); } +void Vec_MemFreeP_imctk_abc_sys(Vec_Mem_t **p) { Vec_MemFreeP(p); } +Vec_Mem_t * Vec_MemDup_imctk_abc_sys(Vec_Mem_t *pVec) { return Vec_MemDup(pVec); } +void Vec_MemFill_imctk_abc_sys(Vec_Mem_t *pVec, int nEntries) { Vec_MemFill(pVec, nEntries); } +void Vec_MemClean_imctk_abc_sys(Vec_Mem_t *pVec, int nEntries) { Vec_MemClean(pVec, nEntries); } +int Vec_MemEntrySize_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemEntrySize(p); } +int Vec_MemEntryNum_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemEntryNum(p); } +int Vec_MemPageSize_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemPageSize(p); } +int Vec_MemPageNum_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemPageNum(p); } +double Vec_MemMemory_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemMemory(p); } +word * Vec_MemReadEntry_imctk_abc_sys(Vec_Mem_t *p, int i) { return Vec_MemReadEntry(p, i); } +word * Vec_MemReadEntryLast_imctk_abc_sys(Vec_Mem_t *p) { return Vec_MemReadEntryLast(p); } +void Vec_MemWriteEntry_imctk_abc_sys(Vec_Mem_t *p, int i, word *pEntry) { Vec_MemWriteEntry(p, i, pEntry); } +word * Vec_MemGetEntry_imctk_abc_sys(Vec_Mem_t *p, int i) { return Vec_MemGetEntry(p, i); } +void Vec_MemSetEntry_imctk_abc_sys(Vec_Mem_t *p, int i, word *pEntry) { Vec_MemSetEntry(p, i, pEntry); } +void Vec_MemPush_imctk_abc_sys(Vec_Mem_t *p, word *pEntry) { Vec_MemPush(p, pEntry); } +void Vec_MemShrink_imctk_abc_sys(Vec_Mem_t *p, int nEntriesNew) { Vec_MemShrink(p, nEntriesNew); } +void Vec_MemDumpDigit_imctk_abc_sys(FILE *pFile, int HexDigit) { Vec_MemDumpDigit(pFile, HexDigit); } +void Vec_MemDump_imctk_abc_sys(FILE *pFile, Vec_Mem_t *pVec) { Vec_MemDump(pFile, pVec); } +void Vec_MemHashAlloc_imctk_abc_sys(Vec_Mem_t *p, int nTableSize) { Vec_MemHashAlloc(p, nTableSize); } +void Vec_MemHashFree_imctk_abc_sys(Vec_Mem_t *p) { Vec_MemHashFree(p); } +unsigned int Vec_MemHashKey_imctk_abc_sys(Vec_Mem_t *p, word *pEntry) { return Vec_MemHashKey(p, pEntry); } +int * Vec_MemHashLookup_imctk_abc_sys(Vec_Mem_t *p, word *pEntry) { return Vec_MemHashLookup(p, pEntry); } +void Vec_MemHashProfile_imctk_abc_sys(Vec_Mem_t *p) { Vec_MemHashProfile(p); } +void Vec_MemHashResize_imctk_abc_sys(Vec_Mem_t *p) { Vec_MemHashResize(p); } +int Vec_MemHashInsert_imctk_abc_sys(Vec_Mem_t *p, word *pEntry) { return Vec_MemHashInsert(p, pEntry); } +Vec_Mem_t * Vec_MemAllocForTTSimple_imctk_abc_sys(int nVars) { return Vec_MemAllocForTTSimple(nVars); } +Vec_Mem_t * Vec_MemAllocForTT_imctk_abc_sys(int nVars, int fCompl) { return Vec_MemAllocForTT(nVars, fCompl); } +void Vec_MemAddMuxTT_imctk_abc_sys(Vec_Mem_t *p, int nVars) { Vec_MemAddMuxTT(p, nVars); } +void Vec_MemDumpTruthTables_imctk_abc_sys(Vec_Mem_t *p, char *pName, int nLutSize) { Vec_MemDumpTruthTables(p, pName, nLutSize); } +Vec_Wec_t * Vec_WecAlloc_imctk_abc_sys(int nCap) { return Vec_WecAlloc(nCap); } +Vec_Wec_t * Vec_WecAllocExact_imctk_abc_sys(int nCap) { return Vec_WecAllocExact(nCap); } +Vec_Wec_t * Vec_WecStart_imctk_abc_sys(int nSize) { return Vec_WecStart(nSize); } +void Vec_WecGrow_imctk_abc_sys(Vec_Wec_t *p, int nCapMin) { Vec_WecGrow(p, nCapMin); } +void Vec_WecInit_imctk_abc_sys(Vec_Wec_t *p, int nSize) { Vec_WecInit(p, nSize); } +Vec_Int_t * Vec_WecEntry_imctk_abc_sys(Vec_Wec_t *p, int i) { return Vec_WecEntry(p, i); } +Vec_Int_t * Vec_WecEntryLast_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecEntryLast(p); } +int Vec_WecEntryEntry_imctk_abc_sys(Vec_Wec_t *p, int i, int k) { return Vec_WecEntryEntry(p, i, k); } +Vec_Int_t * Vec_WecArray_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecArray(p); } +int Vec_WecLevelId_imctk_abc_sys(Vec_Wec_t *p, Vec_Int_t *vLevel) { return Vec_WecLevelId(p, vLevel); } +int Vec_WecCap_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecCap(p); } +int Vec_WecSize_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecSize(p); } +int Vec_WecLevelSize_imctk_abc_sys(Vec_Wec_t *p, int i) { return Vec_WecLevelSize(p, i); } +int Vec_WecSizeSize_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecSizeSize(p); } +int Vec_WecSizeUsed_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecSizeUsed(p); } +int Vec_WecSizeUsedLimits_imctk_abc_sys(Vec_Wec_t *p, int iStart, int iStop) { return Vec_WecSizeUsedLimits(p, iStart, iStop); } +void Vec_WecShrink_imctk_abc_sys(Vec_Wec_t *p, int nSizeNew) { Vec_WecShrink(p, nSizeNew); } +void Vec_WecClear_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecClear(p); } +void Vec_WecClearLevels_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecClearLevels(p); } +void Vec_WecPush_imctk_abc_sys(Vec_Wec_t *p, int Level, int Entry) { Vec_WecPush(p, Level, Entry); } +void Vec_WecPushTwo_imctk_abc_sys(Vec_Wec_t *p, int Level, int Entry1, int Entry2) { Vec_WecPushTwo(p, Level, Entry1, Entry2); } +Vec_Int_t * Vec_WecPushLevel_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecPushLevel(p); } +Vec_Int_t * Vec_WecInsertLevel_imctk_abc_sys(Vec_Wec_t *p, int i) { return Vec_WecInsertLevel(p, i); } +double Vec_WecMemory_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecMemory(p); } +void Vec_WecZero_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecZero(p); } +void Vec_WecErase_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecErase(p); } +void Vec_WecFree_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecFree(p); } +void Vec_WecFreeP_imctk_abc_sys(Vec_Wec_t **p) { Vec_WecFreeP(p); } +void Vec_WecPushUnique_imctk_abc_sys(Vec_Wec_t *p, int Level, int Entry) { Vec_WecPushUnique(p, Level, Entry); } +Vec_Wec_t * Vec_WecDup_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecDup(p); } +int Vec_WecSortCompare1_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare1(p1, p2); } +int Vec_WecSortCompare2_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare2(p1, p2); } +void Vec_WecSort_imctk_abc_sys(Vec_Wec_t *p, int fReverse) { Vec_WecSort(p, fReverse); } +int Vec_WecSortCompare3_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare3(p1, p2); } +int Vec_WecSortCompare4_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare4(p1, p2); } +void Vec_WecSortByFirstInt_imctk_abc_sys(Vec_Wec_t *p, int fReverse) { Vec_WecSortByFirstInt(p, fReverse); } +int Vec_WecSortCompare5_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare5(p1, p2); } +int Vec_WecSortCompare6_imctk_abc_sys(Vec_Int_t *p1, Vec_Int_t *p2) { return Vec_WecSortCompare6(p1, p2); } +void Vec_WecSortByLastInt_imctk_abc_sys(Vec_Wec_t *p, int fReverse) { Vec_WecSortByLastInt(p, fReverse); } +void Vec_WecKeepLevels_imctk_abc_sys(Vec_Wec_t *p, int Limit) { Vec_WecKeepLevels(p, Limit); } +void Vec_WecPrint_imctk_abc_sys(Vec_Wec_t *p, int fSkipSingles) { Vec_WecPrint(p, fSkipSingles); } +void Vec_WecPrintLits_imctk_abc_sys(Vec_Wec_t *p) { Vec_WecPrintLits(p); } +Vec_Wec_t * Vec_WecCreateClasses_imctk_abc_sys(Vec_Int_t *vMap) { return Vec_WecCreateClasses(vMap); } +int Vec_WecCountNonTrivial_imctk_abc_sys(Vec_Wec_t *p, int *pnUsed) { return Vec_WecCountNonTrivial(p, pnUsed); } +int Vec_WecMaxLevelSize_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecMaxLevelSize(p); } +Vec_Int_t * Vec_WecCollectFirsts_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecCollectFirsts(p); } +Vec_Ptr_t * Vec_WecConvertToVecPtr_imctk_abc_sys(Vec_Wec_t *p) { return Vec_WecConvertToVecPtr(p); } +int Vec_WecIntHasMark_imctk_abc_sys(Vec_Int_t *vVec) { return Vec_WecIntHasMark(vVec); } +void Vec_WecIntSetMark_imctk_abc_sys(Vec_Int_t *vVec) { Vec_WecIntSetMark(vVec); } +void Vec_WecIntXorMark_imctk_abc_sys(Vec_Int_t *vVec) { Vec_WecIntXorMark(vVec); } +void Vec_WecMarkLevels_imctk_abc_sys(Vec_Wec_t *vCubes, Vec_Int_t *vLevels) { Vec_WecMarkLevels(vCubes, vLevels); } +void Vec_WecUnmarkLevels_imctk_abc_sys(Vec_Wec_t *vCubes, Vec_Int_t *vLevels) { Vec_WecUnmarkLevels(vCubes, vLevels); } +void Vec_WecRemoveEmpty_imctk_abc_sys(Vec_Wec_t *vCubes) { Vec_WecRemoveEmpty(vCubes); } +void Vec_WecDumpBin_imctk_abc_sys(char *pFileName, Vec_Wec_t *p, int fVerbose) { Vec_WecDumpBin(pFileName, p, fVerbose); } +Vec_Wec_t * Vec_WecReadBin_imctk_abc_sys(char *pFileName, int fVerbose) { return Vec_WecReadBin(pFileName, fVerbose); } +unsigned int Gia_ObjCutSign_imctk_abc_sys(unsigned int ObjId) { return Gia_ObjCutSign(ObjId); } +int Gia_WordHasOneBit_imctk_abc_sys(unsigned int uWord) { return Gia_WordHasOneBit(uWord); } +int Gia_WordHasOnePair_imctk_abc_sys(unsigned int uWord) { return Gia_WordHasOnePair(uWord); } +int Gia_WordCountOnes_imctk_abc_sys(unsigned int uWord) { return Gia_WordCountOnes(uWord); } +int Gia_WordFindFirstBit_imctk_abc_sys(unsigned int uWord) { return Gia_WordFindFirstBit(uWord); } +int Gia_ManTruthIsConst0_imctk_abc_sys(unsigned int *pIn, int nVars) { return Gia_ManTruthIsConst0(pIn, nVars); } +int Gia_ManTruthIsConst1_imctk_abc_sys(unsigned int *pIn, int nVars) { return Gia_ManTruthIsConst1(pIn, nVars); } +void Gia_ManTruthCopy_imctk_abc_sys(unsigned int *pOut, unsigned int *pIn, int nVars) { Gia_ManTruthCopy(pOut, pIn, nVars); } +void Gia_ManTruthClear_imctk_abc_sys(unsigned int *pOut, int nVars) { Gia_ManTruthClear(pOut, nVars); } +void Gia_ManTruthFill_imctk_abc_sys(unsigned int *pOut, int nVars) { Gia_ManTruthFill(pOut, nVars); } +void Gia_ManTruthNot_imctk_abc_sys(unsigned int *pOut, unsigned int *pIn, int nVars) { Gia_ManTruthNot(pOut, pIn, nVars); } +int Gia_ManConst0Lit_imctk_abc_sys(void) { return Gia_ManConst0Lit(); } +int Gia_ManConst1Lit_imctk_abc_sys(void) { return Gia_ManConst1Lit(); } +int Gia_ManIsConst0Lit_imctk_abc_sys(int iLit) { return Gia_ManIsConst0Lit(iLit); } +int Gia_ManIsConst1Lit_imctk_abc_sys(int iLit) { return Gia_ManIsConst1Lit(iLit); } +int Gia_ManIsConstLit_imctk_abc_sys(int iLit) { return Gia_ManIsConstLit(iLit); } +Gia_Obj_t * Gia_Regular_imctk_abc_sys(Gia_Obj_t *p) { return Gia_Regular(p); } +Gia_Obj_t * Gia_Not_imctk_abc_sys(Gia_Obj_t *p) { return Gia_Not(p); } +Gia_Obj_t * Gia_NotCond_imctk_abc_sys(Gia_Obj_t *p, int c) { return Gia_NotCond(p, c); } +int Gia_IsComplement_imctk_abc_sys(Gia_Obj_t *p) { return Gia_IsComplement(p); } +char * Gia_ManName_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManName(p); } +int Gia_ManCiNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManCiNum(p); } +int Gia_ManCoNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManCoNum(p); } +int Gia_ManPiNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManPiNum(p); } +int Gia_ManPoNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManPoNum(p); } +int Gia_ManRegNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManRegNum(p); } +int Gia_ManObjNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManObjNum(p); } +int Gia_ManAndNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManAndNum(p); } +int Gia_ManXorNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManXorNum(p); } +int Gia_ManMuxNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManMuxNum(p); } +int Gia_ManBufNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManBufNum(p); } +int Gia_ManAndNotBufNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManAndNotBufNum(p); } +int Gia_ManCandNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManCandNum(p); } +int Gia_ManConstrNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManConstrNum(p); } +void Gia_ManFlipVerbose_imctk_abc_sys(Gia_Man_t *p) { Gia_ManFlipVerbose(p); } +int Gia_ManHasChoices_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManHasChoices(p); } +int Gia_ManChoiceNum_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManChoiceNum(p); } +Gia_Obj_t * Gia_ManConst0_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManConst0(p); } +Gia_Obj_t * Gia_ManConst1_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManConst1(p); } +Gia_Obj_t * Gia_ManObj_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManObj(p, v); } +Gia_Obj_t * Gia_ManCi_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManCi(p, v); } +Gia_Obj_t * Gia_ManCo_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManCo(p, v); } +Gia_Obj_t * Gia_ManPi_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManPi(p, v); } +Gia_Obj_t * Gia_ManPo_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManPo(p, v); } +Gia_Obj_t * Gia_ManRo_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManRo(p, v); } +Gia_Obj_t * Gia_ManRi_imctk_abc_sys(Gia_Man_t *p, int v) { return Gia_ManRi(p, v); } +int Gia_ObjId_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjId(p, pObj); } +int Gia_ObjCioId_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjCioId(pObj); } +void Gia_ObjSetCioId_imctk_abc_sys(Gia_Obj_t *pObj, int v) { Gia_ObjSetCioId(pObj, v); } +int Gia_ObjValue_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjValue(pObj); } +void Gia_ObjSetValue_imctk_abc_sys(Gia_Obj_t *pObj, int i) { Gia_ObjSetValue(pObj, i); } +int Gia_ObjPhase_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjPhase(pObj); } +int Gia_ObjPhaseReal_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjPhaseReal(pObj); } +int Gia_ObjPhaseDiff_imctk_abc_sys(Gia_Man_t *p, int i, int k) { return Gia_ObjPhaseDiff(p, i, k); } +char * Gia_ObjCiName_imctk_abc_sys(Gia_Man_t *p, int i) { return Gia_ObjCiName(p, i); } +char * Gia_ObjCoName_imctk_abc_sys(Gia_Man_t *p, int i) { return Gia_ObjCoName(p, i); } +char * Gia_ObjName_imctk_abc_sys(Gia_Man_t *p, int i) { return Gia_ObjName(p, i); } +char * Gia_ObjNameObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjNameObj(p, pObj); } +int Gia_ObjIsTerm_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsTerm(pObj); } +int Gia_ObjIsAndOrConst0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsAndOrConst0(pObj); } +int Gia_ObjIsCi_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsCi(pObj); } +int Gia_ObjIsCo_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsCo(pObj); } +int Gia_ObjIsAnd_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsAnd(pObj); } +int Gia_ObjIsXor_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsXor(pObj); } +int Gia_ObjIsMuxId_imctk_abc_sys(Gia_Man_t *p, int iObj) { return Gia_ObjIsMuxId(p, iObj); } +int Gia_ObjIsMux_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsMux(p, pObj); } +int Gia_ObjIsAndReal_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsAndReal(p, pObj); } +int Gia_ObjIsBuf_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsBuf(pObj); } +int Gia_ObjIsAndNotBuf_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsAndNotBuf(pObj); } +int Gia_ObjIsCand_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsCand(pObj); } +int Gia_ObjIsConst0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjIsConst0(pObj); } +int Gia_ManObjIsConst0_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ManObjIsConst0(p, pObj); } +int Gia_Obj2Lit_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_Obj2Lit(p, pObj); } +Gia_Obj_t * Gia_Lit2Obj_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_Lit2Obj(p, iLit); } +int Gia_ManCiLit_imctk_abc_sys(Gia_Man_t *p, int CiId) { return Gia_ManCiLit(p, CiId); } +int Gia_ManIdToCioId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ManIdToCioId(p, Id); } +int Gia_ManCiIdToId_imctk_abc_sys(Gia_Man_t *p, int CiId) { return Gia_ManCiIdToId(p, CiId); } +int Gia_ManCoIdToId_imctk_abc_sys(Gia_Man_t *p, int CoId) { return Gia_ManCoIdToId(p, CoId); } +int Gia_ObjIsPi_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsPi(p, pObj); } +int Gia_ObjIsPo_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsPo(p, pObj); } +int Gia_ObjIsRo_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsRo(p, pObj); } +int Gia_ObjIsRi_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsRi(p, pObj); } +Gia_Obj_t * Gia_ObjRoToRi_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjRoToRi(p, pObj); } +Gia_Obj_t * Gia_ObjRiToRo_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjRiToRo(p, pObj); } +int Gia_ObjRoToRiId_imctk_abc_sys(Gia_Man_t *p, int ObjId) { return Gia_ObjRoToRiId(p, ObjId); } +int Gia_ObjRiToRoId_imctk_abc_sys(Gia_Man_t *p, int ObjId) { return Gia_ObjRiToRoId(p, ObjId); } +int Gia_ObjDiff0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjDiff0(pObj); } +int Gia_ObjDiff1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjDiff1(pObj); } +int Gia_ObjFaninC0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFaninC0(pObj); } +int Gia_ObjFaninC1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFaninC1(pObj); } +int Gia_ObjFaninC2_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninC2(p, pObj); } +int Gia_ObjFaninC_imctk_abc_sys(Gia_Obj_t *pObj, int n) { return Gia_ObjFaninC(pObj, n); } +Gia_Obj_t * Gia_ObjFanin0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFanin0(pObj); } +Gia_Obj_t * Gia_ObjFanin1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFanin1(pObj); } +Gia_Obj_t * Gia_ObjFanin2_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanin2(p, pObj); } +Gia_Obj_t * Gia_ObjFanin_imctk_abc_sys(Gia_Obj_t *pObj, int n) { return Gia_ObjFanin(pObj, n); } +Gia_Obj_t * Gia_ObjChild0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjChild0(pObj); } +Gia_Obj_t * Gia_ObjChild1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjChild1(pObj); } +Gia_Obj_t * Gia_ObjChild2_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjChild2(p, pObj); } +int Gia_ObjFaninId0_imctk_abc_sys(Gia_Obj_t *pObj, int ObjId) { return Gia_ObjFaninId0(pObj, ObjId); } +int Gia_ObjFaninId1_imctk_abc_sys(Gia_Obj_t *pObj, int ObjId) { return Gia_ObjFaninId1(pObj, ObjId); } +int Gia_ObjFaninId2_imctk_abc_sys(Gia_Man_t *p, int ObjId) { return Gia_ObjFaninId2(p, ObjId); } +int Gia_ObjFaninId_imctk_abc_sys(Gia_Obj_t *pObj, int ObjId, int n) { return Gia_ObjFaninId(pObj, ObjId, n); } +int Gia_ObjFaninId0p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninId0p(p, pObj); } +int Gia_ObjFaninId1p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninId1p(p, pObj); } +int Gia_ObjFaninId2p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninId2p(p, pObj); } +int Gia_ObjFaninIdp_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int n) { return Gia_ObjFaninIdp(p, pObj, n); } +int Gia_ObjFaninLit0_imctk_abc_sys(Gia_Obj_t *pObj, int ObjId) { return Gia_ObjFaninLit0(pObj, ObjId); } +int Gia_ObjFaninLit1_imctk_abc_sys(Gia_Obj_t *pObj, int ObjId) { return Gia_ObjFaninLit1(pObj, ObjId); } +int Gia_ObjFaninLit2_imctk_abc_sys(Gia_Man_t *p, int ObjId) { return Gia_ObjFaninLit2(p, ObjId); } +int Gia_ObjFaninLit0p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninLit0p(p, pObj); } +int Gia_ObjFaninLit1p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninLit1p(p, pObj); } +int Gia_ObjFaninLit2p_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninLit2p(p, pObj); } +void Gia_ObjFlipFaninC0_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjFlipFaninC0(pObj); } +int Gia_ObjFaninNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFaninNum(p, pObj); } +int Gia_ObjWhatFanin_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pFanin) { return Gia_ObjWhatFanin(p, pObj, pFanin); } +int Gia_ManCoDriverId_imctk_abc_sys(Gia_Man_t *p, int iCoIndex) { return Gia_ManCoDriverId(p, iCoIndex); } +int Gia_ManPoIsConst_imctk_abc_sys(Gia_Man_t *p, int iPoIndex) { return Gia_ManPoIsConst(p, iPoIndex); } +int Gia_ManPoIsConst0_imctk_abc_sys(Gia_Man_t *p, int iPoIndex) { return Gia_ManPoIsConst0(p, iPoIndex); } +int Gia_ManPoIsConst1_imctk_abc_sys(Gia_Man_t *p, int iPoIndex) { return Gia_ManPoIsConst1(p, iPoIndex); } +Gia_Obj_t * Gia_ObjCopy_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjCopy(p, pObj); } +int Gia_ObjLitCopy_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjLitCopy(p, iLit); } +int Gia_ObjFanin0Copy_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFanin0Copy(pObj); } +int Gia_ObjFanin1Copy_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjFanin1Copy(pObj); } +int Gia_ObjFanin2Copy_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanin2Copy(p, pObj); } +int Gia_ObjCopyF_imctk_abc_sys(Gia_Man_t *p, int f, Gia_Obj_t *pObj) { return Gia_ObjCopyF(p, f, pObj); } +void Gia_ObjSetCopyF_imctk_abc_sys(Gia_Man_t *p, int f, Gia_Obj_t *pObj, int iLit) { Gia_ObjSetCopyF(p, f, pObj, iLit); } +int Gia_ObjCopyArray_imctk_abc_sys(Gia_Man_t *p, int iObj) { return Gia_ObjCopyArray(p, iObj); } +void Gia_ObjSetCopyArray_imctk_abc_sys(Gia_Man_t *p, int iObj, int iLit) { Gia_ObjSetCopyArray(p, iObj, iLit); } +void Gia_ManCleanCopyArray_imctk_abc_sys(Gia_Man_t *p) { Gia_ManCleanCopyArray(p); } +int Gia_ObjCopy2Array_imctk_abc_sys(Gia_Man_t *p, int iObj) { return Gia_ObjCopy2Array(p, iObj); } +void Gia_ObjSetCopy2Array_imctk_abc_sys(Gia_Man_t *p, int iObj, int iLit) { Gia_ObjSetCopy2Array(p, iObj, iLit); } +void Gia_ManCleanCopy2Array_imctk_abc_sys(Gia_Man_t *p) { Gia_ManCleanCopy2Array(p); } +int Gia_ObjFanin0CopyF_imctk_abc_sys(Gia_Man_t *p, int f, Gia_Obj_t *pObj) { return Gia_ObjFanin0CopyF(p, f, pObj); } +int Gia_ObjFanin1CopyF_imctk_abc_sys(Gia_Man_t *p, int f, Gia_Obj_t *pObj) { return Gia_ObjFanin1CopyF(p, f, pObj); } +int Gia_ObjFanin0CopyArray_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanin0CopyArray(p, pObj); } +int Gia_ObjFanin1CopyArray_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanin1CopyArray(p, pObj); } +Gia_Obj_t * Gia_ObjFromLit_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjFromLit(p, iLit); } +int Gia_ObjToLit_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjToLit(p, pObj); } +int Gia_ObjPhaseRealLit_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjPhaseRealLit(p, iLit); } +int Gia_ObjLevelId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLevelId(p, Id); } +int Gia_ObjLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjLevel(p, pObj); } +void Gia_ObjUpdateLevelId_imctk_abc_sys(Gia_Man_t *p, int Id, int l) { Gia_ObjUpdateLevelId(p, Id, l); } +void Gia_ObjSetLevelId_imctk_abc_sys(Gia_Man_t *p, int Id, int l) { Gia_ObjSetLevelId(p, Id, l); } +void Gia_ObjSetLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int l) { Gia_ObjSetLevel(p, pObj, l); } +void Gia_ObjSetCoLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetCoLevel(p, pObj); } +void Gia_ObjSetBufLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetBufLevel(p, pObj); } +void Gia_ObjSetAndLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetAndLevel(p, pObj); } +void Gia_ObjSetXorLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetXorLevel(p, pObj); } +void Gia_ObjSetMuxLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetMuxLevel(p, pObj); } +void Gia_ObjSetGateLevel_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetGateLevel(p, pObj); } +int Gia_ObjHasNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjHasNumId(p, Id); } +int Gia_ObjNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjNumId(p, Id); } +int Gia_ObjNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjNum(p, pObj); } +void Gia_ObjSetNumId_imctk_abc_sys(Gia_Man_t *p, int Id, int n) { Gia_ObjSetNumId(p, Id, n); } +void Gia_ObjSetNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int n) { Gia_ObjSetNum(p, pObj, n); } +void Gia_ObjResetNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjResetNumId(p, Id); } +int Gia_ObjRefNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjRefNumId(p, Id); } +int Gia_ObjRefIncId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjRefIncId(p, Id); } +int Gia_ObjRefDecId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjRefDecId(p, Id); } +int Gia_ObjRefNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjRefNum(p, pObj); } +int Gia_ObjRefInc_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjRefInc(p, pObj); } +int Gia_ObjRefDec_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjRefDec(p, pObj); } +void Gia_ObjRefFanin0Inc_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin0Inc(p, pObj); } +void Gia_ObjRefFanin1Inc_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin1Inc(p, pObj); } +void Gia_ObjRefFanin2Inc_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin2Inc(p, pObj); } +void Gia_ObjRefFanin0Dec_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin0Dec(p, pObj); } +void Gia_ObjRefFanin1Dec_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin1Dec(p, pObj); } +void Gia_ObjRefFanin2Dec_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjRefFanin2Dec(p, pObj); } +int Gia_ObjLutRefNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutRefNumId(p, Id); } +int Gia_ObjLutRefIncId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutRefIncId(p, Id); } +int Gia_ObjLutRefDecId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutRefDecId(p, Id); } +int Gia_ObjLutRefNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjLutRefNum(p, pObj); } +int Gia_ObjLutRefInc_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjLutRefInc(p, pObj); } +int Gia_ObjLutRefDec_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjLutRefDec(p, pObj); } +void Gia_ObjSetTravIdCurrent_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetTravIdCurrent(p, pObj); } +void Gia_ObjSetTravIdPrevious_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjSetTravIdPrevious(p, pObj); } +int Gia_ObjIsTravIdCurrent_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsTravIdCurrent(p, pObj); } +int Gia_ObjIsTravIdPrevious_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjIsTravIdPrevious(p, pObj); } +int Gia_ObjUpdateTravIdCurrent_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjUpdateTravIdCurrent(p, pObj); } +int Gia_ObjUpdateTravIdPrevious_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjUpdateTravIdPrevious(p, pObj); } +void Gia_ObjSetTravIdCurrentId_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjSetTravIdCurrentId(p, Id); } +void Gia_ObjSetTravIdPreviousId_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjSetTravIdPreviousId(p, Id); } +int Gia_ObjIsTravIdCurrentId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsTravIdCurrentId(p, Id); } +int Gia_ObjIsTravIdPreviousId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsTravIdPreviousId(p, Id); } +int Gia_ObjUpdateTravIdCurrentId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjUpdateTravIdCurrentId(p, Id); } +int Gia_ObjUpdateTravIdPreviousId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjUpdateTravIdPreviousId(p, Id); } +void Gia_ManTimeClean_imctk_abc_sys(Gia_Man_t *p) { Gia_ManTimeClean(p); } +void Gia_ManTimeStart_imctk_abc_sys(Gia_Man_t *p) { Gia_ManTimeStart(p); } +void Gia_ManTimeStop_imctk_abc_sys(Gia_Man_t *p) { Gia_ManTimeStop(p); } +float Gia_ObjTimeArrival_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjTimeArrival(p, Id); } +float Gia_ObjTimeRequired_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjTimeRequired(p, Id); } +float Gia_ObjTimeSlack_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjTimeSlack(p, Id); } +float Gia_ObjTimeArrivalObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjTimeArrivalObj(p, pObj); } +float Gia_ObjTimeRequiredObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjTimeRequiredObj(p, pObj); } +float Gia_ObjTimeSlackObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjTimeSlackObj(p, pObj); } +void Gia_ObjSetTimeArrival_imctk_abc_sys(Gia_Man_t *p, int Id, float t) { Gia_ObjSetTimeArrival(p, Id, t); } +void Gia_ObjSetTimeRequired_imctk_abc_sys(Gia_Man_t *p, int Id, float t) { Gia_ObjSetTimeRequired(p, Id, t); } +void Gia_ObjSetTimeSlack_imctk_abc_sys(Gia_Man_t *p, int Id, float t) { Gia_ObjSetTimeSlack(p, Id, t); } +void Gia_ObjSetTimeArrivalObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, float t) { Gia_ObjSetTimeArrivalObj(p, pObj, t); } +void Gia_ObjSetTimeRequiredObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, float t) { Gia_ObjSetTimeRequiredObj(p, pObj, t); } +void Gia_ObjSetTimeSlackObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, float t) { Gia_ObjSetTimeSlackObj(p, pObj, t); } +int Gia_ObjSimWords_imctk_abc_sys(Gia_Man_t *p) { return Gia_ObjSimWords(p); } +word * Gia_ObjSimPi_imctk_abc_sys(Gia_Man_t *p, int PiId) { return Gia_ObjSimPi(p, PiId); } +word * Gia_ObjSim_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjSim(p, Id); } +word * Gia_ObjSimObj_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjSimObj(p, pObj); } +Gia_Obj_t * Gia_ManAppendObj_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManAppendObj(p); } +int Gia_ManAppendCi_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManAppendCi(p); } +int Gia_ManAppendAnd_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendAnd(p, iLit0, iLit1); } +int Gia_ManAppendXorReal_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendXorReal(p, iLit0, iLit1); } +int Gia_ManAppendMuxReal_imctk_abc_sys(Gia_Man_t *p, int iLitC, int iLit1, int iLit0) { return Gia_ManAppendMuxReal(p, iLitC, iLit1, iLit0); } +int Gia_ManAppendBuf_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ManAppendBuf(p, iLit); } +int Gia_ManAppendCo_imctk_abc_sys(Gia_Man_t *p, int iLit0) { return Gia_ManAppendCo(p, iLit0); } +int Gia_ManAppendOr_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendOr(p, iLit0, iLit1); } +int Gia_ManAppendMux_imctk_abc_sys(Gia_Man_t *p, int iCtrl, int iData1, int iData0) { return Gia_ManAppendMux(p, iCtrl, iData1, iData0); } +int Gia_ManAppendMaj_imctk_abc_sys(Gia_Man_t *p, int iData0, int iData1, int iData2) { return Gia_ManAppendMaj(p, iData0, iData1, iData2); } +int Gia_ManAppendXor_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendXor(p, iLit0, iLit1); } +int Gia_ManAppendAnd2_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendAnd2(p, iLit0, iLit1); } +int Gia_ManAppendOr2_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendOr2(p, iLit0, iLit1); } +int Gia_ManAppendMux2_imctk_abc_sys(Gia_Man_t *p, int iCtrl, int iData1, int iData0) { return Gia_ManAppendMux2(p, iCtrl, iData1, iData0); } +int Gia_ManAppendMaj2_imctk_abc_sys(Gia_Man_t *p, int iData0, int iData1, int iData2) { return Gia_ManAppendMaj2(p, iData0, iData1, iData2); } +int Gia_ManAppendXor2_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendXor2(p, iLit0, iLit1); } +int Gia_ManAppendXorReal2_imctk_abc_sys(Gia_Man_t *p, int iLit0, int iLit1) { return Gia_ManAppendXorReal2(p, iLit0, iLit1); } +void Gia_ManPatchCoDriver_imctk_abc_sys(Gia_Man_t *p, int iCoIndex, int iLit0) { Gia_ManPatchCoDriver(p, iCoIndex, iLit0); } +int Gia_XsimNotCond_imctk_abc_sys(int Value, int fCompl) { return Gia_XsimNotCond(Value, fCompl); } +int Gia_XsimAndCond_imctk_abc_sys(int Value0, int fCompl0, int Value1, int fCompl1) { return Gia_XsimAndCond(Value0, fCompl0, Value1, fCompl1); } +void Gia_ObjTerSimSetC_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimSetC(pObj); } +void Gia_ObjTerSimSet0_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimSet0(pObj); } +void Gia_ObjTerSimSet1_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimSet1(pObj); } +void Gia_ObjTerSimSetX_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimSetX(pObj); } +int Gia_ObjTerSimGetC_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGetC(pObj); } +int Gia_ObjTerSimGet0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet0(pObj); } +int Gia_ObjTerSimGet1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet1(pObj); } +int Gia_ObjTerSimGetX_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGetX(pObj); } +int Gia_ObjTerSimGet0Fanin0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet0Fanin0(pObj); } +int Gia_ObjTerSimGet1Fanin0_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet1Fanin0(pObj); } +int Gia_ObjTerSimGet0Fanin1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet0Fanin1(pObj); } +int Gia_ObjTerSimGet1Fanin1_imctk_abc_sys(Gia_Obj_t *pObj) { return Gia_ObjTerSimGet1Fanin1(pObj); } +void Gia_ObjTerSimAnd_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimAnd(pObj); } +void Gia_ObjTerSimCo_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimCo(pObj); } +void Gia_ObjTerSimRo_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { Gia_ObjTerSimRo(p, pObj); } +void Gia_ObjTerSimPrint_imctk_abc_sys(Gia_Obj_t *pObj) { Gia_ObjTerSimPrint(pObj); } +int Gia_AigerReadInt_imctk_abc_sys(unsigned char *pPos) { return Gia_AigerReadInt(pPos); } +void Gia_AigerWriteInt_imctk_abc_sys(unsigned char *pPos, int Value) { Gia_AigerWriteInt(pPos, Value); } +unsigned int Gia_AigerReadUnsigned_imctk_abc_sys(unsigned char **ppPos) { return Gia_AigerReadUnsigned(ppPos); } +void Gia_AigerWriteUnsigned_imctk_abc_sys(Vec_Str_t *vStr, unsigned int x) { Gia_AigerWriteUnsigned(vStr, x); } +void Gia_AigerWriteUnsignedFile_imctk_abc_sys(FILE *pFile, unsigned int x) { Gia_AigerWriteUnsignedFile(pFile, x); } +int Gia_AigerWriteUnsignedBuffer_imctk_abc_sys(unsigned char *pBuffer, int Pos, unsigned int x) { return Gia_AigerWriteUnsignedBuffer(pBuffer, Pos, x); } +Gia_Obj_t * Gia_ObjReprObj_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjReprObj(p, Id); } +int Gia_ObjRepr_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjRepr(p, Id); } +void Gia_ObjSetRepr_imctk_abc_sys(Gia_Man_t *p, int Id, int Num) { Gia_ObjSetRepr(p, Id, Num); } +void Gia_ObjSetReprRev_imctk_abc_sys(Gia_Man_t *p, int Id, int Num) { Gia_ObjSetReprRev(p, Id, Num); } +void Gia_ObjUnsetRepr_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjUnsetRepr(p, Id); } +int Gia_ObjHasRepr_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjHasRepr(p, Id); } +int Gia_ObjReprSelf_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjReprSelf(p, Id); } +int Gia_ObjSibl_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjSibl(p, Id); } +Gia_Obj_t * Gia_ObjSiblObj_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjSiblObj(p, Id); } +int Gia_ObjProved_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjProved(p, Id); } +void Gia_ObjSetProved_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjSetProved(p, Id); } +void Gia_ObjUnsetProved_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjUnsetProved(p, Id); } +int Gia_ObjFailed_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjFailed(p, Id); } +void Gia_ObjSetFailed_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjSetFailed(p, Id); } +int Gia_ObjColor_imctk_abc_sys(Gia_Man_t *p, int Id, int c) { return Gia_ObjColor(p, Id, c); } +int Gia_ObjColors_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjColors(p, Id); } +void Gia_ObjSetColor_imctk_abc_sys(Gia_Man_t *p, int Id, int c) { Gia_ObjSetColor(p, Id, c); } +void Gia_ObjSetColors_imctk_abc_sys(Gia_Man_t *p, int Id) { Gia_ObjSetColors(p, Id); } +int Gia_ObjVisitColor_imctk_abc_sys(Gia_Man_t *p, int Id, int c) { return Gia_ObjVisitColor(p, Id, c); } +int Gia_ObjDiffColors_imctk_abc_sys(Gia_Man_t *p, int i, int j) { return Gia_ObjDiffColors(p, i, j); } +int Gia_ObjDiffColors2_imctk_abc_sys(Gia_Man_t *p, int i, int j) { return Gia_ObjDiffColors2(p, i, j); } +Gia_Obj_t * Gia_ObjNextObj_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjNextObj(p, Id); } +int Gia_ObjNext_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjNext(p, Id); } +void Gia_ObjSetNext_imctk_abc_sys(Gia_Man_t *p, int Id, int Num) { Gia_ObjSetNext(p, Id, Num); } +int Gia_ObjIsConst_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsConst(p, Id); } +int Gia_ObjIsHead_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsHead(p, Id); } +int Gia_ObjIsNone_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsNone(p, Id); } +int Gia_ObjIsTail_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsTail(p, Id); } +int Gia_ObjIsClass_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsClass(p, Id); } +int Gia_ObjHasSameRepr_imctk_abc_sys(Gia_Man_t *p, int i, int k) { return Gia_ObjHasSameRepr(p, i, k); } +int Gia_ObjIsFailedPair_imctk_abc_sys(Gia_Man_t *p, int i, int k) { return Gia_ObjIsFailedPair(p, i, k); } +int Gia_ClassIsPair_imctk_abc_sys(Gia_Man_t *p, int i) { return Gia_ClassIsPair(p, i); } +void Gia_ClassUndoPair_imctk_abc_sys(Gia_Man_t *p, int i) { Gia_ClassUndoPair(p, i); } +int Gia_ObjFoffsetId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjFoffsetId(p, Id); } +int Gia_ObjFoffset_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFoffset(p, pObj); } +int Gia_ObjFanoutNumId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjFanoutNumId(p, Id); } +int Gia_ObjFanoutNum_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanoutNum(p, pObj); } +int Gia_ObjFanoutId_imctk_abc_sys(Gia_Man_t *p, int Id, int i) { return Gia_ObjFanoutId(p, Id, i); } +Gia_Obj_t * Gia_ObjFanout0_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj) { return Gia_ObjFanout0(p, pObj); } +Gia_Obj_t * Gia_ObjFanout_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int i) { return Gia_ObjFanout(p, pObj, i); } +void Gia_ObjSetFanout_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int i, Gia_Obj_t *pFan) { Gia_ObjSetFanout(p, pObj, i, pFan); } +void Gia_ObjSetFanoutInt_imctk_abc_sys(Gia_Man_t *p, Gia_Obj_t *pObj, int i, int x) { Gia_ObjSetFanoutInt(p, pObj, i, x); } +int Gia_ManHasMapping_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManHasMapping(p); } +int Gia_ObjIsLut_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsLut(p, Id); } +int Gia_ObjLutSize_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutSize(p, Id); } +int * Gia_ObjLutFanins_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutFanins(p, Id); } +int Gia_ObjLutFanin_imctk_abc_sys(Gia_Man_t *p, int Id, int i) { return Gia_ObjLutFanin(p, Id, i); } +int Gia_ObjLutMuxId_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutMuxId(p, Id); } +int Gia_ObjLutIsMux_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutIsMux(p, Id); } +int Gia_ManHasMapping2_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManHasMapping2(p); } +int Gia_ObjIsLut2_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjIsLut2(p, Id); } +int Gia_ObjLutSize2_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutSize2(p, Id); } +Vec_Int_t * Gia_ObjLutFanins2_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutFanins2(p, Id); } +int Gia_ObjLutFanin2_imctk_abc_sys(Gia_Man_t *p, int Id, int i) { return Gia_ObjLutFanin2(p, Id, i); } +int Gia_ObjLutFanoutNum2_imctk_abc_sys(Gia_Man_t *p, int Id) { return Gia_ObjLutFanoutNum2(p, Id); } +int Gia_ObjLutFanout2_imctk_abc_sys(Gia_Man_t *p, int Id, int i) { return Gia_ObjLutFanout2(p, Id, i); } +int Gia_ManHasCellMapping_imctk_abc_sys(Gia_Man_t *p) { return Gia_ManHasCellMapping(p); } +int Gia_ObjIsCell_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjIsCell(p, iLit); } +int Gia_ObjIsCellInv_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjIsCellInv(p, iLit); } +int Gia_ObjIsCellBuf_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjIsCellBuf(p, iLit); } +int Gia_ObjCellSize_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjCellSize(p, iLit); } +int * Gia_ObjCellFanins_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjCellFanins(p, iLit); } +int Gia_ObjCellFanin_imctk_abc_sys(Gia_Man_t *p, int iLit, int i) { return Gia_ObjCellFanin(p, iLit, i); } +int Gia_ObjCellId_imctk_abc_sys(Gia_Man_t *p, int iLit) { return Gia_ObjCellId(p, iLit); } diff --git a/abc-sys/src/generated/bindings.d b/abc-sys/src/generated/bindings.d new file mode 100644 index 0000000..c003b9a --- /dev/null +++ b/abc-sys/src/generated/bindings.d @@ -0,0 +1,2 @@ + abc/src/aig/gia/gia.h abc/src/misc/util/abc_global.h abc/src/misc/util/abc_namespaces.h abc/src/misc/util/utilCex.h abc/src/misc/vec/vec.h abc/src/misc/vec/vecAtt.h abc/src/misc/vec/vecBit.h abc/src/misc/vec/vecFlt.h abc/src/misc/vec/vecInt.h abc/src/misc/vec/vecMem.h abc/src/misc/vec/vecPtr.h abc/src/misc/vec/vecStr.h abc/src/misc/vec/vecVec.h abc/src/misc/vec/vecWec.h abc/src/misc/vec/vecWrd.h abc/src/proof/cec/cec.h src/bindings.h +codegen.sh diff --git a/abc-sys/src/generated/bindings.rs b/abc-sys/src/generated/bindings.rs new file mode 100644 index 0000000..4ee8e83 --- /dev/null +++ b/abc-sys/src/generated/bindings.rs @@ -0,0 +1,12676 @@ +/* automatically generated by rust-bindgen 0.69.4 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + 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); + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +pub const SIZEOF_VOID_P: u32 = 8; +pub const SIZEOF_LONG: u32 = 8; +pub const SIZEOF_INT: u32 = 4; +pub const ABC_INFINITY: u32 = 1000000000; +pub const APPLE_MACH: u32 = 0; +pub const BRIDGE_NETLIST: u32 = 106; +pub const BRIDGE_ABS_NETLIST: u32 = 107; +pub const GIA_NONE: u32 = 536870911; +pub const GIA_VOID: u32 = 268435455; +pub const GIA_ZER: u32 = 1; +pub const GIA_ONE: u32 = 2; +pub const GIA_UND: u32 = 3; +pub type ABC_PTRDIFF_T = isize; +pub type ABC_PTRUINT_T = usize; +pub type ABC_PTRINT_T = isize; +pub type ABC_INT64_T = i64; +pub type ABC_UINT64_T = u64; +pub type word = ABC_UINT64_T; +pub type iword = ABC_INT64_T; +extern "C" { + #[link_name = "Abc_AbsInt_imctk_abc_sys"] + pub fn Abc_AbsInt(a: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_MaxInt_imctk_abc_sys"] + pub fn Abc_MaxInt(a: ::std::os::raw::c_int, b: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_MinInt_imctk_abc_sys"] + pub fn Abc_MinInt(a: ::std::os::raw::c_int, b: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_MaxWord_imctk_abc_sys"] + pub fn Abc_MaxWord(a: word, b: word) -> word; +} +extern "C" { + #[link_name = "Abc_MinWord_imctk_abc_sys"] + pub fn Abc_MinWord(a: word, b: word) -> word; +} +extern "C" { + #[link_name = "Abc_AbsFloat_imctk_abc_sys"] + pub fn Abc_AbsFloat(a: f32) -> f32; +} +extern "C" { + #[link_name = "Abc_MaxFloat_imctk_abc_sys"] + pub fn Abc_MaxFloat(a: f32, b: f32) -> f32; +} +extern "C" { + #[link_name = "Abc_MinFloat_imctk_abc_sys"] + pub fn Abc_MinFloat(a: f32, b: f32) -> f32; +} +extern "C" { + #[link_name = "Abc_AbsDouble_imctk_abc_sys"] + pub fn Abc_AbsDouble(a: f64) -> f64; +} +extern "C" { + #[link_name = "Abc_MaxDouble_imctk_abc_sys"] + pub fn Abc_MaxDouble(a: f64, b: f64) -> f64; +} +extern "C" { + #[link_name = "Abc_MinDouble_imctk_abc_sys"] + pub fn Abc_MinDouble(a: f64, b: f64) -> f64; +} +extern "C" { + #[link_name = "Abc_Float2Int_imctk_abc_sys"] + pub fn Abc_Float2Int(Val: f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Int2Float_imctk_abc_sys"] + pub fn Abc_Int2Float(Num: ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Abc_Dbl2Word_imctk_abc_sys"] + pub fn Abc_Dbl2Word(Dbl: f64) -> word; +} +extern "C" { + #[link_name = "Abc_Word2Dbl_imctk_abc_sys"] + pub fn Abc_Word2Dbl(Num: word) -> f64; +} +extern "C" { + #[link_name = "Abc_Base2Log_imctk_abc_sys"] + pub fn Abc_Base2Log(n: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Base10Log_imctk_abc_sys"] + pub fn Abc_Base10Log(n: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Base16Log_imctk_abc_sys"] + pub fn Abc_Base16Log(n: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_UtilStrsav_imctk_abc_sys"] + pub fn Abc_UtilStrsav(s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Abc_UtilStrsavTwo_imctk_abc_sys"] + pub fn Abc_UtilStrsavTwo( + s: *mut ::std::os::raw::c_char, + a: *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Abc_UtilStrsavNum_imctk_abc_sys"] + pub fn Abc_UtilStrsavNum( + s: *mut ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Abc_BitByteNum_imctk_abc_sys"] + pub fn Abc_BitByteNum(nBits: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_BitWordNum_imctk_abc_sys"] + pub fn Abc_BitWordNum(nBits: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Bit6WordNum_imctk_abc_sys"] + pub fn Abc_Bit6WordNum(nBits: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_TruthByteNum_imctk_abc_sys"] + pub fn Abc_TruthByteNum(nVars: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_TruthWordNum_imctk_abc_sys"] + pub fn Abc_TruthWordNum(nVars: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Truth6WordNum_imctk_abc_sys"] + pub fn Abc_Truth6WordNum(nVars: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_InfoHasBit_imctk_abc_sys"] + pub fn Abc_InfoHasBit( + p: *mut ::std::os::raw::c_uint, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_InfoSetBit_imctk_abc_sys"] + pub fn Abc_InfoSetBit(p: *mut ::std::os::raw::c_uint, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Abc_InfoXorBit_imctk_abc_sys"] + pub fn Abc_InfoXorBit(p: *mut ::std::os::raw::c_uint, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Abc_InfoMask_imctk_abc_sys"] + pub fn Abc_InfoMask(nVar: ::std::os::raw::c_int) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Abc_Var2Lit_imctk_abc_sys"] + pub fn Abc_Var2Lit( + Var: ::std::os::raw::c_int, + c: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Var_imctk_abc_sys"] + pub fn Abc_Lit2Var(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_LitIsCompl_imctk_abc_sys"] + pub fn Abc_LitIsCompl(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_LitNot_imctk_abc_sys"] + pub fn Abc_LitNot(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_LitNotCond_imctk_abc_sys"] + pub fn Abc_LitNotCond( + Lit: ::std::os::raw::c_int, + c: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_LitRegular_imctk_abc_sys"] + pub fn Abc_LitRegular(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2LitV_imctk_abc_sys"] + pub fn Abc_Lit2LitV( + pMap: *mut ::std::os::raw::c_int, + Lit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2LitL_imctk_abc_sys"] + pub fn Abc_Lit2LitL( + pMap: *mut ::std::os::raw::c_int, + Lit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Ptr2Int_imctk_abc_sys"] + pub fn Abc_Ptr2Int(p: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Int2Ptr_imctk_abc_sys"] + pub fn Abc_Int2Ptr(i: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Abc_Ptr2Wrd_imctk_abc_sys"] + pub fn Abc_Ptr2Wrd(p: *mut ::std::os::raw::c_void) -> word; +} +extern "C" { + #[link_name = "Abc_Wrd2Ptr_imctk_abc_sys"] + pub fn Abc_Wrd2Ptr(i: word) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Abc_Var2Lit2_imctk_abc_sys"] + pub fn Abc_Var2Lit2( + Var: ::std::os::raw::c_int, + Att: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Var2_imctk_abc_sys"] + pub fn Abc_Lit2Var2(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Att2_imctk_abc_sys"] + pub fn Abc_Lit2Att2(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Var2Lit3_imctk_abc_sys"] + pub fn Abc_Var2Lit3( + Var: ::std::os::raw::c_int, + Att: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Var3_imctk_abc_sys"] + pub fn Abc_Lit2Var3(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Att3_imctk_abc_sys"] + pub fn Abc_Lit2Att3(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Var2Lit4_imctk_abc_sys"] + pub fn Abc_Var2Lit4( + Var: ::std::os::raw::c_int, + Att: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Var4_imctk_abc_sys"] + pub fn Abc_Lit2Var4(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_Lit2Att4_imctk_abc_sys"] + pub fn Abc_Lit2Att4(Lit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +pub type abctime = ABC_INT64_T; +extern "C" { + #[link_name = "Abc_Clock_imctk_abc_sys"] + pub fn Abc_Clock() -> abctime; +} +extern "C" { + #[link_name = "Abc_ThreadClock_imctk_abc_sys"] + pub fn Abc_ThreadClock() -> abctime; +} +pub const Abc_VerbLevel_ABC_PROMPT: Abc_VerbLevel = -2; +pub const Abc_VerbLevel_ABC_ERROR: Abc_VerbLevel = -1; +pub const Abc_VerbLevel_ABC_WARNING: Abc_VerbLevel = 0; +pub const Abc_VerbLevel_ABC_STANDARD: Abc_VerbLevel = 1; +pub const Abc_VerbLevel_ABC_VERBOSE: Abc_VerbLevel = 2; +pub type Abc_VerbLevel = ::std::os::raw::c_int; +extern "C" { + pub fn Gia_ManToBridgeText( + pFile: *mut FILE, + Size: ::std::os::raw::c_int, + pBuffer: *mut ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManToBridgeAbsNetlist( + pFile: *mut FILE, + p: *mut ::std::os::raw::c_void, + pkg_type: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn nsprintf(format: *const ::std::os::raw::c_char, ...) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Abc_PrintInt_imctk_abc_sys"] + pub fn Abc_PrintInt(i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Abc_PrintTime_imctk_abc_sys"] + pub fn Abc_PrintTime( + level: ::std::os::raw::c_int, + pStr: *const ::std::os::raw::c_char, + time: abctime, + ); +} +extern "C" { + #[link_name = "Abc_PrintTimeP_imctk_abc_sys"] + pub fn Abc_PrintTimeP( + level: ::std::os::raw::c_int, + pStr: *const ::std::os::raw::c_char, + time: abctime, + Time: abctime, + ); +} +extern "C" { + #[link_name = "Abc_PrintMemoryP_imctk_abc_sys"] + pub fn Abc_PrintMemoryP( + level: ::std::os::raw::c_int, + pStr: *const ::std::os::raw::c_char, + mem: ::std::os::raw::c_int, + Mem: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Abc_PrimeCudd_imctk_abc_sys"] + pub fn Abc_PrimeCudd(p: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Abc_FileReadContents_imctk_abc_sys"] + pub fn Abc_FileReadContents( + pFileName: *mut ::std::os::raw::c_char, + pnFileSize: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Abc_ReverseOrder_imctk_abc_sys"] + pub fn Abc_ReverseOrder(pA: *mut ::std::os::raw::c_int, nA: ::std::os::raw::c_int); +} +extern "C" { + pub fn Abc_MergeSort(pInput: *mut ::std::os::raw::c_int, nSize: ::std::os::raw::c_int); +} +extern "C" { + pub fn Abc_MergeSortCost( + pCosts: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn Abc_MergeSortCost2( + pInput: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + pCost: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_MergeSortCost2Reverse( + pInput: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + pCost: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_QuickSort1( + pData: *mut word, + nSize: ::std::os::raw::c_int, + fDecrease: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_QuickSort2( + pData: *mut word, + nSize: ::std::os::raw::c_int, + fDecrease: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_QuickSort3( + pData: *mut word, + nSize: ::std::os::raw::c_int, + fDecrease: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_QuickSortCostData( + pCosts: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + fDecrease: ::std::os::raw::c_int, + pData: *mut word, + pResult: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Abc_QuickSortCost( + pCosts: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + fDecrease: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn Abc_Random(fReset: ::std::os::raw::c_int) -> ::std::os::raw::c_uint; +} +extern "C" { + pub fn Abc_RandomW(fReset: ::std::os::raw::c_int) -> word; +} +pub type Vec_Int_t = Vec_Int_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Int_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Vec_Int_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Int_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Int_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Int_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Int_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Int_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_IntAlloc_imctk_abc_sys"] + pub fn Vec_IntAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntAllocExact_imctk_abc_sys"] + pub fn Vec_IntAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntStart_imctk_abc_sys"] + pub fn Vec_IntStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntStartFull_imctk_abc_sys"] + pub fn Vec_IntStartFull(nSize: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntStartRange_imctk_abc_sys"] + pub fn Vec_IntStartRange( + First: ::std::os::raw::c_int, + Range: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntStartRandomLimit_imctk_abc_sys"] + pub fn Vec_IntStartRandomLimit( + nSize: ::std::os::raw::c_int, + Upper: ::std::os::raw::c_int, + Lower: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntRandomizeOrder_imctk_abc_sys"] + pub fn Vec_IntRandomizeOrder(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntStartNatural_imctk_abc_sys"] + pub fn Vec_IntStartNatural(nSize: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntAllocArray_imctk_abc_sys"] + pub fn Vec_IntAllocArray( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntAllocArrayCopy_imctk_abc_sys"] + pub fn Vec_IntAllocArrayCopy( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntDup_imctk_abc_sys"] + pub fn Vec_IntDup(pVec: *mut Vec_Int_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntDupArray_imctk_abc_sys"] + pub fn Vec_IntDupArray(pVec: *mut Vec_Int_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntZero_imctk_abc_sys"] + pub fn Vec_IntZero(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntErase_imctk_abc_sys"] + pub fn Vec_IntErase(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntFree_imctk_abc_sys"] + pub fn Vec_IntFree(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntFreeP_imctk_abc_sys"] + pub fn Vec_IntFreeP(p: *mut *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntReleaseArray_imctk_abc_sys"] + pub fn Vec_IntReleaseArray(p: *mut Vec_Int_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntReleaseNewArray_imctk_abc_sys"] + pub fn Vec_IntReleaseNewArray(p: *mut Vec_Int_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntArray_imctk_abc_sys"] + pub fn Vec_IntArray(p: *mut Vec_Int_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntArrayP_imctk_abc_sys"] + pub fn Vec_IntArrayP(p: *mut Vec_Int_t) -> *mut *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntLimit_imctk_abc_sys"] + pub fn Vec_IntLimit(p: *mut Vec_Int_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSize_imctk_abc_sys"] + pub fn Vec_IntSize(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCap_imctk_abc_sys"] + pub fn Vec_IntCap(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntMemory_imctk_abc_sys"] + pub fn Vec_IntMemory(p: *mut Vec_Int_t) -> f64; +} +extern "C" { + #[link_name = "Vec_IntEntry_imctk_abc_sys"] + pub fn Vec_IntEntry(p: *mut Vec_Int_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntEntryP_imctk_abc_sys"] + pub fn Vec_IntEntryP(p: *mut Vec_Int_t, i: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntWriteEntry_imctk_abc_sys"] + pub fn Vec_IntWriteEntry( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntAddToEntry_imctk_abc_sys"] + pub fn Vec_IntAddToEntry( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Addition: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUpdateEntry_imctk_abc_sys"] + pub fn Vec_IntUpdateEntry( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Value: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntDowndateEntry_imctk_abc_sys"] + pub fn Vec_IntDowndateEntry( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Value: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntEntryLast_imctk_abc_sys"] + pub fn Vec_IntEntryLast(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntGrow_imctk_abc_sys"] + pub fn Vec_IntGrow(p: *mut Vec_Int_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntGrowResize_imctk_abc_sys"] + pub fn Vec_IntGrowResize(p: *mut Vec_Int_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntFill_imctk_abc_sys"] + pub fn Vec_IntFill( + p: *mut Vec_Int_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntFillTwo_imctk_abc_sys"] + pub fn Vec_IntFillTwo( + p: *mut Vec_Int_t, + nSize: ::std::os::raw::c_int, + FillEven: ::std::os::raw::c_int, + FillOdd: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntFillNatural_imctk_abc_sys"] + pub fn Vec_IntFillNatural(p: *mut Vec_Int_t, nSize: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntFillExtra_imctk_abc_sys"] + pub fn Vec_IntFillExtra( + p: *mut Vec_Int_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntGetEntry_imctk_abc_sys"] + pub fn Vec_IntGetEntry(p: *mut Vec_Int_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntGetEntryFull_imctk_abc_sys"] + pub fn Vec_IntGetEntryFull( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntGetEntryP_imctk_abc_sys"] + pub fn Vec_IntGetEntryP( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSetEntry_imctk_abc_sys"] + pub fn Vec_IntSetEntry( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntSetEntryFull_imctk_abc_sys"] + pub fn Vec_IntSetEntryFull( + p: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntShrink_imctk_abc_sys"] + pub fn Vec_IntShrink(p: *mut Vec_Int_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntClear_imctk_abc_sys"] + pub fn Vec_IntClear(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntPush_imctk_abc_sys"] + pub fn Vec_IntPush(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntPushReturn_imctk_abc_sys"] + pub fn Vec_IntPushReturn( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntPushTwo_imctk_abc_sys"] + pub fn Vec_IntPushTwo( + p: *mut Vec_Int_t, + Entry1: ::std::os::raw::c_int, + Entry2: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntPushThree_imctk_abc_sys"] + pub fn Vec_IntPushThree( + p: *mut Vec_Int_t, + Entry1: ::std::os::raw::c_int, + Entry2: ::std::os::raw::c_int, + Entry3: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntPushFour_imctk_abc_sys"] + pub fn Vec_IntPushFour( + p: *mut Vec_Int_t, + Entry1: ::std::os::raw::c_int, + Entry2: ::std::os::raw::c_int, + Entry3: ::std::os::raw::c_int, + Entry4: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntPushArray_imctk_abc_sys"] + pub fn Vec_IntPushArray( + p: *mut Vec_Int_t, + pEntries: *mut ::std::os::raw::c_int, + nEntries: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntShift_imctk_abc_sys"] + pub fn Vec_IntShift(p: *mut Vec_Int_t, Shift: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntPushFirst_imctk_abc_sys"] + pub fn Vec_IntPushFirst(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntPushOrder_imctk_abc_sys"] + pub fn Vec_IntPushOrder(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntPushOrderCost_imctk_abc_sys"] + pub fn Vec_IntPushOrderCost( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + vCost: *mut Vec_Int_t, + ); +} +extern "C" { + #[link_name = "Vec_IntIsOrdered_imctk_abc_sys"] + pub fn Vec_IntIsOrdered( + p: *mut Vec_Int_t, + fReverse: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntIsOrderedCost_imctk_abc_sys"] + pub fn Vec_IntIsOrderedCost( + p: *mut Vec_Int_t, + vCost: *mut Vec_Int_t, + fReverse: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntPushOrderReverse_imctk_abc_sys"] + pub fn Vec_IntPushOrderReverse(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntPushUniqueOrder_imctk_abc_sys"] + pub fn Vec_IntPushUniqueOrder( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntPushUniqueOrderCost_imctk_abc_sys"] + pub fn Vec_IntPushUniqueOrderCost( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + vCost: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntPushUnique_imctk_abc_sys"] + pub fn Vec_IntPushUnique( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntFetch_imctk_abc_sys"] + pub fn Vec_IntFetch( + p: *mut Vec_Int_t, + nWords: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Vec_IntPop_imctk_abc_sys"] + pub fn Vec_IntPop(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntFind_imctk_abc_sys"] + pub fn Vec_IntFind(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntRemove_imctk_abc_sys"] + pub fn Vec_IntRemove(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntRemove1_imctk_abc_sys"] + pub fn Vec_IntRemove1(p: *mut Vec_Int_t, Entry: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntDrop_imctk_abc_sys"] + pub fn Vec_IntDrop(p: *mut Vec_Int_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntInsert_imctk_abc_sys"] + pub fn Vec_IntInsert( + p: *mut Vec_Int_t, + iHere: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntFindMax_imctk_abc_sys"] + pub fn Vec_IntFindMax(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntArgMax_imctk_abc_sys"] + pub fn Vec_IntArgMax(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntFindMin_imctk_abc_sys"] + pub fn Vec_IntFindMin(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntArgMin_imctk_abc_sys"] + pub fn Vec_IntArgMin(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntReverseOrder_imctk_abc_sys"] + pub fn Vec_IntReverseOrder(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntRemoveOdd_imctk_abc_sys"] + pub fn Vec_IntRemoveOdd(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntRemoveEven_imctk_abc_sys"] + pub fn Vec_IntRemoveEven(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntInvert_imctk_abc_sys"] + pub fn Vec_IntInvert(p: *mut Vec_Int_t, Fill: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntCondense_imctk_abc_sys"] + pub fn Vec_IntCondense(p: *mut Vec_Int_t, Fill: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntSum_imctk_abc_sys"] + pub fn Vec_IntSum(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountEntry_imctk_abc_sys"] + pub fn Vec_IntCountEntry( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountLarger_imctk_abc_sys"] + pub fn Vec_IntCountLarger( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountSmaller_imctk_abc_sys"] + pub fn Vec_IntCountSmaller( + p: *mut Vec_Int_t, + Entry: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountPositive_imctk_abc_sys"] + pub fn Vec_IntCountPositive(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountZero_imctk_abc_sys"] + pub fn Vec_IntCountZero(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntAddPositive_imctk_abc_sys"] + pub fn Vec_IntAddPositive(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntEqual_imctk_abc_sys"] + pub fn Vec_IntEqual(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntContained_imctk_abc_sys"] + pub fn Vec_IntContained( + pSmall: *mut Vec_Int_t, + pLarge: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountCommon_imctk_abc_sys"] + pub fn Vec_IntCountCommon(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSortCompare1_imctk_abc_sys"] + pub fn Vec_IntSortCompare1( + pp1: *mut ::std::os::raw::c_int, + pp2: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSortCompare2_imctk_abc_sys"] + pub fn Vec_IntSortCompare2( + pp1: *mut ::std::os::raw::c_int, + pp2: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSort_imctk_abc_sys"] + pub fn Vec_IntSort(p: *mut Vec_Int_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntSortMulti_imctk_abc_sys"] + pub fn Vec_IntSortMulti( + p: *mut Vec_Int_t, + nMulti: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntIsSorted_imctk_abc_sys"] + pub fn Vec_IntIsSorted( + p: *mut Vec_Int_t, + fReverse: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUniqify_imctk_abc_sys"] + pub fn Vec_IntUniqify(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountDuplicates_imctk_abc_sys"] + pub fn Vec_IntCountDuplicates(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCheckUniqueSmall_imctk_abc_sys"] + pub fn Vec_IntCheckUniqueSmall(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntCountUnique_imctk_abc_sys"] + pub fn Vec_IntCountUnique(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUniqifyPairs_imctk_abc_sys"] + pub fn Vec_IntUniqifyPairs(p: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUniqueHashKeyDebug_imctk_abc_sys"] + pub fn Vec_IntUniqueHashKeyDebug( + pStr: *mut ::std::os::raw::c_uchar, + nChars: ::std::os::raw::c_int, + TableMask: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Vec_IntUniqueProfile_imctk_abc_sys"] + pub fn Vec_IntUniqueProfile( + vData: *mut Vec_Int_t, + pTable: *mut ::std::os::raw::c_int, + pNexts: *mut ::std::os::raw::c_int, + TableMask: ::std::os::raw::c_int, + nIntSize: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntUniqueHashKey2_imctk_abc_sys"] + pub fn Vec_IntUniqueHashKey2( + pStr: *mut ::std::os::raw::c_uchar, + nChars: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Vec_IntUniqueHashKey_imctk_abc_sys"] + pub fn Vec_IntUniqueHashKey( + pStr: *mut ::std::os::raw::c_uchar, + nChars: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Vec_IntUniqueLookup_imctk_abc_sys"] + pub fn Vec_IntUniqueLookup( + vData: *mut Vec_Int_t, + i: ::std::os::raw::c_int, + nIntSize: ::std::os::raw::c_int, + pNexts: *mut ::std::os::raw::c_int, + pStart: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUniqueCount_imctk_abc_sys"] + pub fn Vec_IntUniqueCount( + vData: *mut Vec_Int_t, + nIntSize: ::std::os::raw::c_int, + pvMap: *mut *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntUniqifyHash_imctk_abc_sys"] + pub fn Vec_IntUniqifyHash( + vData: *mut Vec_Int_t, + nIntSize: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntSortCompareUnsigned_imctk_abc_sys"] + pub fn Vec_IntSortCompareUnsigned( + pp1: *mut ::std::os::raw::c_uint, + pp2: *mut ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntSortUnsigned_imctk_abc_sys"] + pub fn Vec_IntSortUnsigned(p: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntTwoCountCommon_imctk_abc_sys"] + pub fn Vec_IntTwoCountCommon( + vArr1: *mut Vec_Int_t, + vArr2: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntTwoFindCommon_imctk_abc_sys"] + pub fn Vec_IntTwoFindCommon( + vArr1: *mut Vec_Int_t, + vArr2: *mut Vec_Int_t, + vArr: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntTwoFindCommonReverse_imctk_abc_sys"] + pub fn Vec_IntTwoFindCommonReverse( + vArr1: *mut Vec_Int_t, + vArr2: *mut Vec_Int_t, + vArr: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntTwoRemoveCommon_imctk_abc_sys"] + pub fn Vec_IntTwoRemoveCommon( + vArr1: *mut Vec_Int_t, + vArr2: *mut Vec_Int_t, + vArr: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntTwoRemove_imctk_abc_sys"] + pub fn Vec_IntTwoRemove(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntTwoMerge1_imctk_abc_sys"] + pub fn Vec_IntTwoMerge1(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntTwoRemove1_imctk_abc_sys"] + pub fn Vec_IntTwoRemove1(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntTwoMerge2Int_imctk_abc_sys"] + pub fn Vec_IntTwoMerge2Int(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t, vArr: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntTwoMerge_imctk_abc_sys"] + pub fn Vec_IntTwoMerge(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_IntTwoMerge2_imctk_abc_sys"] + pub fn Vec_IntTwoMerge2(vArr1: *mut Vec_Int_t, vArr2: *mut Vec_Int_t, vArr: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntTwoSplit_imctk_abc_sys"] + pub fn Vec_IntTwoSplit( + vArr1: *mut Vec_Int_t, + vArr2: *mut Vec_Int_t, + vArr: *mut Vec_Int_t, + vArr1n: *mut Vec_Int_t, + vArr2n: *mut Vec_Int_t, + ); +} +extern "C" { + #[link_name = "Vec_IntSelectSort_imctk_abc_sys"] + pub fn Vec_IntSelectSort(pArray: *mut ::std::os::raw::c_int, nSize: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_IntSelectSortReverse_imctk_abc_sys"] + pub fn Vec_IntSelectSortReverse( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntSelectSortCost_imctk_abc_sys"] + pub fn Vec_IntSelectSortCost( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + vCosts: *mut Vec_Int_t, + ); +} +extern "C" { + #[link_name = "Vec_IntSelectSortCostReverse_imctk_abc_sys"] + pub fn Vec_IntSelectSortCostReverse( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + vCosts: *mut Vec_Int_t, + ); +} +extern "C" { + #[link_name = "Vec_IntSelectSortCost2_imctk_abc_sys"] + pub fn Vec_IntSelectSortCost2( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + pCosts: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntSelectSortCost2Reverse_imctk_abc_sys"] + pub fn Vec_IntSelectSortCost2Reverse( + pArray: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + pCosts: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntPrint_imctk_abc_sys"] + pub fn Vec_IntPrint(vVec: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntPrintBinary_imctk_abc_sys"] + pub fn Vec_IntPrintBinary(vVec: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntCompareVec_imctk_abc_sys"] + pub fn Vec_IntCompareVec(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_IntClearAppend_imctk_abc_sys"] + pub fn Vec_IntClearAppend(vVec1: *mut Vec_Int_t, vVec2: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntAppend_imctk_abc_sys"] + pub fn Vec_IntAppend(vVec1: *mut Vec_Int_t, vVec2: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_IntAppendSkip_imctk_abc_sys"] + pub fn Vec_IntAppendSkip( + vVec1: *mut Vec_Int_t, + vVec2: *mut Vec_Int_t, + iVar: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntAppendMinus_imctk_abc_sys"] + pub fn Vec_IntAppendMinus( + vVec1: *mut Vec_Int_t, + vVec2: *mut Vec_Int_t, + fMinus: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntRemapArray_imctk_abc_sys"] + pub fn Vec_IntRemapArray( + vOld2New: *mut Vec_Int_t, + vOld: *mut Vec_Int_t, + vNew: *mut Vec_Int_t, + nNew: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntDumpBin_imctk_abc_sys"] + pub fn Vec_IntDumpBin( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Int_t, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_IntReadBin_imctk_abc_sys"] + pub fn Vec_IntReadBin( + pFileName: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +pub type Vec_Flt_t = Vec_Flt_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Flt_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut f32, +} +#[test] +fn bindgen_test_layout_Vec_Flt_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Flt_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Flt_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Flt_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Flt_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Flt_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_FltAlloc_imctk_abc_sys"] + pub fn Vec_FltAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltAllocExact_imctk_abc_sys"] + pub fn Vec_FltAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltStart_imctk_abc_sys"] + pub fn Vec_FltStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltStartFull_imctk_abc_sys"] + pub fn Vec_FltStartFull(nSize: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltAllocArray_imctk_abc_sys"] + pub fn Vec_FltAllocArray(pArray: *mut f32, nSize: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltAllocArrayCopy_imctk_abc_sys"] + pub fn Vec_FltAllocArrayCopy(pArray: *mut f32, nSize: ::std::os::raw::c_int) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltDup_imctk_abc_sys"] + pub fn Vec_FltDup(pVec: *mut Vec_Flt_t) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltDupArray_imctk_abc_sys"] + pub fn Vec_FltDupArray(pVec: *mut Vec_Flt_t) -> *mut Vec_Flt_t; +} +extern "C" { + #[link_name = "Vec_FltZero_imctk_abc_sys"] + pub fn Vec_FltZero(p: *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltErase_imctk_abc_sys"] + pub fn Vec_FltErase(p: *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltFree_imctk_abc_sys"] + pub fn Vec_FltFree(p: *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltFreeP_imctk_abc_sys"] + pub fn Vec_FltFreeP(p: *mut *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltReleaseArray_imctk_abc_sys"] + pub fn Vec_FltReleaseArray(p: *mut Vec_Flt_t) -> *mut f32; +} +extern "C" { + #[link_name = "Vec_FltArray_imctk_abc_sys"] + pub fn Vec_FltArray(p: *mut Vec_Flt_t) -> *mut f32; +} +extern "C" { + #[link_name = "Vec_FltArrayP_imctk_abc_sys"] + pub fn Vec_FltArrayP(p: *mut Vec_Flt_t) -> *mut *mut f32; +} +extern "C" { + #[link_name = "Vec_FltSize_imctk_abc_sys"] + pub fn Vec_FltSize(p: *mut Vec_Flt_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltCap_imctk_abc_sys"] + pub fn Vec_FltCap(p: *mut Vec_Flt_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltMemory_imctk_abc_sys"] + pub fn Vec_FltMemory(p: *mut Vec_Flt_t) -> f64; +} +extern "C" { + #[link_name = "Vec_FltEntry_imctk_abc_sys"] + pub fn Vec_FltEntry(p: *mut Vec_Flt_t, i: ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Vec_FltEntryP_imctk_abc_sys"] + pub fn Vec_FltEntryP(p: *mut Vec_Flt_t, i: ::std::os::raw::c_int) -> *mut f32; +} +extern "C" { + #[link_name = "Vec_FltWriteEntry_imctk_abc_sys"] + pub fn Vec_FltWriteEntry(p: *mut Vec_Flt_t, i: ::std::os::raw::c_int, Entry: f32); +} +extern "C" { + #[link_name = "Vec_FltAddToEntry_imctk_abc_sys"] + pub fn Vec_FltAddToEntry(p: *mut Vec_Flt_t, i: ::std::os::raw::c_int, Addition: f32); +} +extern "C" { + #[link_name = "Vec_FltUpdateEntry_imctk_abc_sys"] + pub fn Vec_FltUpdateEntry(p: *mut Vec_Flt_t, i: ::std::os::raw::c_int, Value: f32); +} +extern "C" { + #[link_name = "Vec_FltEntryLast_imctk_abc_sys"] + pub fn Vec_FltEntryLast(p: *mut Vec_Flt_t) -> f32; +} +extern "C" { + #[link_name = "Vec_FltGrow_imctk_abc_sys"] + pub fn Vec_FltGrow(p: *mut Vec_Flt_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_FltFill_imctk_abc_sys"] + pub fn Vec_FltFill(p: *mut Vec_Flt_t, nSize: ::std::os::raw::c_int, Entry: f32); +} +extern "C" { + #[link_name = "Vec_FltFillExtra_imctk_abc_sys"] + pub fn Vec_FltFillExtra(p: *mut Vec_Flt_t, nSize: ::std::os::raw::c_int, Fill: f32); +} +extern "C" { + #[link_name = "Vec_FltShrink_imctk_abc_sys"] + pub fn Vec_FltShrink(p: *mut Vec_Flt_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_FltClear_imctk_abc_sys"] + pub fn Vec_FltClear(p: *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltPush_imctk_abc_sys"] + pub fn Vec_FltPush(p: *mut Vec_Flt_t, Entry: f32); +} +extern "C" { + #[link_name = "Vec_FltPushOrder_imctk_abc_sys"] + pub fn Vec_FltPushOrder(p: *mut Vec_Flt_t, Entry: f32); +} +extern "C" { + #[link_name = "Vec_FltPushUnique_imctk_abc_sys"] + pub fn Vec_FltPushUnique(p: *mut Vec_Flt_t, Entry: f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltPop_imctk_abc_sys"] + pub fn Vec_FltPop(p: *mut Vec_Flt_t) -> f32; +} +extern "C" { + #[link_name = "Vec_FltFind_imctk_abc_sys"] + pub fn Vec_FltFind(p: *mut Vec_Flt_t, Entry: f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltRemove_imctk_abc_sys"] + pub fn Vec_FltRemove(p: *mut Vec_Flt_t, Entry: f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltFindMax_imctk_abc_sys"] + pub fn Vec_FltFindMax(p: *mut Vec_Flt_t) -> f32; +} +extern "C" { + #[link_name = "Vec_FltFindMin_imctk_abc_sys"] + pub fn Vec_FltFindMin(p: *mut Vec_Flt_t) -> f32; +} +extern "C" { + #[link_name = "Vec_FltEqual_imctk_abc_sys"] + pub fn Vec_FltEqual(p1: *mut Vec_Flt_t, p2: *mut Vec_Flt_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltPrint_imctk_abc_sys"] + pub fn Vec_FltPrint(vVec: *mut Vec_Flt_t); +} +extern "C" { + #[link_name = "Vec_FltSortCompare1_imctk_abc_sys"] + pub fn Vec_FltSortCompare1(pp1: *mut f32, pp2: *mut f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltSortCompare2_imctk_abc_sys"] + pub fn Vec_FltSortCompare2(pp1: *mut f32, pp2: *mut f32) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_FltSort_imctk_abc_sys"] + pub fn Vec_FltSort(p: *mut Vec_Flt_t, fReverse: ::std::os::raw::c_int); +} +pub type Vec_Str_t = Vec_Str_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Str_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_Vec_Str_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Str_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Str_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Str_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Str_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Str_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_StrAlloc_imctk_abc_sys"] + pub fn Vec_StrAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrAllocExact_imctk_abc_sys"] + pub fn Vec_StrAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrStart_imctk_abc_sys"] + pub fn Vec_StrStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrAllocArray_imctk_abc_sys"] + pub fn Vec_StrAllocArray( + pArray: *mut ::std::os::raw::c_char, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrAllocArrayCopy_imctk_abc_sys"] + pub fn Vec_StrAllocArrayCopy( + pArray: *mut ::std::os::raw::c_char, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrDup_imctk_abc_sys"] + pub fn Vec_StrDup(pVec: *mut Vec_Str_t) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrDupArray_imctk_abc_sys"] + pub fn Vec_StrDupArray(pVec: *mut Vec_Str_t) -> *mut Vec_Str_t; +} +extern "C" { + #[link_name = "Vec_StrZero_imctk_abc_sys"] + pub fn Vec_StrZero(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrErase_imctk_abc_sys"] + pub fn Vec_StrErase(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrFree_imctk_abc_sys"] + pub fn Vec_StrFree(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrFreeP_imctk_abc_sys"] + pub fn Vec_StrFreeP(p: *mut *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrReleaseArray_imctk_abc_sys"] + pub fn Vec_StrReleaseArray(p: *mut Vec_Str_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrArray_imctk_abc_sys"] + pub fn Vec_StrArray(p: *mut Vec_Str_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrLimit_imctk_abc_sys"] + pub fn Vec_StrLimit(p: *mut Vec_Str_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrSize_imctk_abc_sys"] + pub fn Vec_StrSize(p: *mut Vec_Str_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrSetSize_imctk_abc_sys"] + pub fn Vec_StrSetSize(p: *mut Vec_Str_t, nSize: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrCap_imctk_abc_sys"] + pub fn Vec_StrCap(p: *mut Vec_Str_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrMemory_imctk_abc_sys"] + pub fn Vec_StrMemory(p: *mut Vec_Str_t) -> f64; +} +extern "C" { + #[link_name = "Vec_StrEntry_imctk_abc_sys"] + pub fn Vec_StrEntry(p: *mut Vec_Str_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrEntryP_imctk_abc_sys"] + pub fn Vec_StrEntryP( + p: *mut Vec_Str_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrWriteEntry_imctk_abc_sys"] + pub fn Vec_StrWriteEntry( + p: *mut Vec_Str_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_char, + ); +} +extern "C" { + #[link_name = "Vec_StrEntryLast_imctk_abc_sys"] + pub fn Vec_StrEntryLast(p: *mut Vec_Str_t) -> ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrGrow_imctk_abc_sys"] + pub fn Vec_StrGrow(p: *mut Vec_Str_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrFill_imctk_abc_sys"] + pub fn Vec_StrFill( + p: *mut Vec_Str_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_char, + ); +} +extern "C" { + #[link_name = "Vec_StrFillExtra_imctk_abc_sys"] + pub fn Vec_StrFillExtra( + p: *mut Vec_Str_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_char, + ); +} +extern "C" { + #[link_name = "Vec_StrGetEntry_imctk_abc_sys"] + pub fn Vec_StrGetEntry(p: *mut Vec_Str_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrSetEntry_imctk_abc_sys"] + pub fn Vec_StrSetEntry( + p: *mut Vec_Str_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_char, + ); +} +extern "C" { + #[link_name = "Vec_StrShrink_imctk_abc_sys"] + pub fn Vec_StrShrink(p: *mut Vec_Str_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrClear_imctk_abc_sys"] + pub fn Vec_StrClear(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrPush_imctk_abc_sys"] + pub fn Vec_StrPush(p: *mut Vec_Str_t, Entry: ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrPushTwo_imctk_abc_sys"] + pub fn Vec_StrPushTwo( + p: *mut Vec_Str_t, + Entry1: ::std::os::raw::c_char, + Entry2: ::std::os::raw::c_char, + ); +} +extern "C" { + #[link_name = "Vec_StrPushBuffer_imctk_abc_sys"] + pub fn Vec_StrPushBuffer( + p: *mut Vec_Str_t, + pBuffer: *mut ::std::os::raw::c_char, + nSize: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_StrPop_imctk_abc_sys"] + pub fn Vec_StrPop(p: *mut Vec_Str_t) -> ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrIntPrint_imctk_abc_sys"] + pub fn Vec_StrIntPrint(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrPrintNum_imctk_abc_sys"] + pub fn Vec_StrPrintNum(p: *mut Vec_Str_t, Num: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrPrintNumStar_imctk_abc_sys"] + pub fn Vec_StrPrintNumStar( + p: *mut Vec_Str_t, + Num: ::std::os::raw::c_int, + nDigits: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_StrPrintStr_imctk_abc_sys"] + pub fn Vec_StrPrintStr(p: *mut Vec_Str_t, pStr: *const ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrAppend_imctk_abc_sys"] + pub fn Vec_StrAppend(p: *mut Vec_Str_t, pString: *const ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrCopy_imctk_abc_sys"] + pub fn Vec_StrCopy(p: *mut Vec_Str_t, pString: *const ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrReverseOrder_imctk_abc_sys"] + pub fn Vec_StrReverseOrder(p: *mut Vec_Str_t); +} +extern "C" { + #[link_name = "Vec_StrSum_imctk_abc_sys"] + pub fn Vec_StrSum(p: *mut Vec_Str_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountEntry_imctk_abc_sys"] + pub fn Vec_StrCountEntry( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountLarger_imctk_abc_sys"] + pub fn Vec_StrCountLarger( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountSmaller_imctk_abc_sys"] + pub fn Vec_StrCountSmaller( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountEntryLit_imctk_abc_sys"] + pub fn Vec_StrCountEntryLit( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountLargerLit_imctk_abc_sys"] + pub fn Vec_StrCountLargerLit( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrCountSmallerLit_imctk_abc_sys"] + pub fn Vec_StrCountSmallerLit( + p: *mut Vec_Str_t, + Entry: ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrEqual_imctk_abc_sys"] + pub fn Vec_StrEqual(p1: *mut Vec_Str_t, p2: *mut Vec_Str_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrSortCompare1_imctk_abc_sys"] + pub fn Vec_StrSortCompare1( + pp1: *mut ::std::os::raw::c_char, + pp2: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrSortCompare2_imctk_abc_sys"] + pub fn Vec_StrSortCompare2( + pp1: *mut ::std::os::raw::c_char, + pp2: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrSort_imctk_abc_sys"] + pub fn Vec_StrSort(p: *mut Vec_Str_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrCompareVec_imctk_abc_sys"] + pub fn Vec_StrCompareVec(p1: *mut Vec_Str_t, p2: *mut Vec_Str_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrPutI_ne_imctk_abc_sys"] + pub fn Vec_StrPutI_ne(vOut: *mut Vec_Str_t, Val: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrGetI_ne_imctk_abc_sys"] + pub fn Vec_StrGetI_ne( + vOut: *mut Vec_Str_t, + pPos: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrPutI_imctk_abc_sys"] + pub fn Vec_StrPutI(vOut: *mut Vec_Str_t, Val: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_StrGetI_imctk_abc_sys"] + pub fn Vec_StrGetI( + vOut: *mut Vec_Str_t, + pPos: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_StrPutW_imctk_abc_sys"] + pub fn Vec_StrPutW(vOut: *mut Vec_Str_t, Val: word); +} +extern "C" { + #[link_name = "Vec_StrGetW_imctk_abc_sys"] + pub fn Vec_StrGetW(vOut: *mut Vec_Str_t, pPos: *mut ::std::os::raw::c_int) -> word; +} +extern "C" { + #[link_name = "Vec_StrPutF_imctk_abc_sys"] + pub fn Vec_StrPutF(vOut: *mut Vec_Str_t, Val: f32); +} +extern "C" { + #[link_name = "Vec_StrGetF_imctk_abc_sys"] + pub fn Vec_StrGetF(vOut: *mut Vec_Str_t, pPos: *mut ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Vec_StrPutD_imctk_abc_sys"] + pub fn Vec_StrPutD(vOut: *mut Vec_Str_t, Val: f64); +} +extern "C" { + #[link_name = "Vec_StrGetD_imctk_abc_sys"] + pub fn Vec_StrGetD(vOut: *mut Vec_Str_t, pPos: *mut ::std::os::raw::c_int) -> f64; +} +extern "C" { + #[link_name = "Vec_StrPutS_imctk_abc_sys"] + pub fn Vec_StrPutS(vOut: *mut Vec_Str_t, pStr: *mut ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrGetS_imctk_abc_sys"] + pub fn Vec_StrGetS( + vOut: *mut Vec_Str_t, + pPos: *mut ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Vec_StrPutC_imctk_abc_sys"] + pub fn Vec_StrPutC(vOut: *mut Vec_Str_t, c: ::std::os::raw::c_char); +} +extern "C" { + #[link_name = "Vec_StrGetC_imctk_abc_sys"] + pub fn Vec_StrGetC( + vOut: *mut Vec_Str_t, + pPos: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_char; +} +pub type Vec_Ptr_t = Vec_Ptr_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Ptr_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_Vec_Ptr_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Ptr_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Ptr_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Ptr_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Ptr_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Ptr_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_PtrAlloc_imctk_abc_sys"] + pub fn Vec_PtrAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrAllocExact_imctk_abc_sys"] + pub fn Vec_PtrAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrStart_imctk_abc_sys"] + pub fn Vec_PtrStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrAllocArray_imctk_abc_sys"] + pub fn Vec_PtrAllocArray( + pArray: *mut *mut ::std::os::raw::c_void, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrAllocArrayCopy_imctk_abc_sys"] + pub fn Vec_PtrAllocArrayCopy( + pArray: *mut *mut ::std::os::raw::c_void, + nSize: ::std::os::raw::c_int, + ) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrDup_imctk_abc_sys"] + pub fn Vec_PtrDup(pVec: *mut Vec_Ptr_t) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrDupStr_imctk_abc_sys"] + pub fn Vec_PtrDupStr(pVec: *mut Vec_Ptr_t) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrDupArray_imctk_abc_sys"] + pub fn Vec_PtrDupArray(pVec: *mut Vec_Ptr_t) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrZero_imctk_abc_sys"] + pub fn Vec_PtrZero(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrErase_imctk_abc_sys"] + pub fn Vec_PtrErase(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrFree_imctk_abc_sys"] + pub fn Vec_PtrFree(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrFreeP_imctk_abc_sys"] + pub fn Vec_PtrFreeP(p: *mut *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrReleaseArray_imctk_abc_sys"] + pub fn Vec_PtrReleaseArray(p: *mut Vec_Ptr_t) -> *mut *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrArray_imctk_abc_sys"] + pub fn Vec_PtrArray(p: *mut Vec_Ptr_t) -> *mut *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrSize_imctk_abc_sys"] + pub fn Vec_PtrSize(p: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrCap_imctk_abc_sys"] + pub fn Vec_PtrCap(p: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrMemory_imctk_abc_sys"] + pub fn Vec_PtrMemory(p: *mut Vec_Ptr_t) -> f64; +} +extern "C" { + #[link_name = "Vec_PtrCountZero_imctk_abc_sys"] + pub fn Vec_PtrCountZero(p: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrEntry_imctk_abc_sys"] + pub fn Vec_PtrEntry(p: *mut Vec_Ptr_t, i: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrEntryP_imctk_abc_sys"] + pub fn Vec_PtrEntryP( + p: *mut Vec_Ptr_t, + i: ::std::os::raw::c_int, + ) -> *mut *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrWriteEntry_imctk_abc_sys"] + pub fn Vec_PtrWriteEntry( + p: *mut Vec_Ptr_t, + i: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrEntryLast_imctk_abc_sys"] + pub fn Vec_PtrEntryLast(p: *mut Vec_Ptr_t) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrGrow_imctk_abc_sys"] + pub fn Vec_PtrGrow(p: *mut Vec_Ptr_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_PtrFill_imctk_abc_sys"] + pub fn Vec_PtrFill( + p: *mut Vec_Ptr_t, + nSize: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrFillTwo_imctk_abc_sys"] + pub fn Vec_PtrFillTwo( + p: *mut Vec_Ptr_t, + nSize: ::std::os::raw::c_int, + EntryEven: *mut ::std::os::raw::c_void, + EntryOdd: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrFillExtra_imctk_abc_sys"] + pub fn Vec_PtrFillExtra( + p: *mut Vec_Ptr_t, + nSize: ::std::os::raw::c_int, + Fill: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrGetEntry_imctk_abc_sys"] + pub fn Vec_PtrGetEntry( + p: *mut Vec_Ptr_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrSetEntry_imctk_abc_sys"] + pub fn Vec_PtrSetEntry( + p: *mut Vec_Ptr_t, + i: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrShrink_imctk_abc_sys"] + pub fn Vec_PtrShrink(p: *mut Vec_Ptr_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_PtrClear_imctk_abc_sys"] + pub fn Vec_PtrClear(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrFreeData_imctk_abc_sys"] + pub fn Vec_PtrFreeData(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrFreeFree_imctk_abc_sys"] + pub fn Vec_PtrFreeFree(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrFreeFunc_imctk_abc_sys"] + pub fn Vec_PtrFreeFunc( + p: *mut Vec_Ptr_t, + pFuncItemFree: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void), + >, + ); +} +extern "C" { + #[link_name = "Vec_PtrCopy_imctk_abc_sys"] + pub fn Vec_PtrCopy(pDest: *mut Vec_Ptr_t, pSour: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrPrintNames_imctk_abc_sys"] + pub fn Vec_PtrPrintNames(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrPush_imctk_abc_sys"] + pub fn Vec_PtrPush(p: *mut Vec_Ptr_t, Entry: *mut ::std::os::raw::c_void); +} +extern "C" { + #[link_name = "Vec_PtrPushTwo_imctk_abc_sys"] + pub fn Vec_PtrPushTwo( + p: *mut Vec_Ptr_t, + Entry1: *mut ::std::os::raw::c_void, + Entry2: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrAppend_imctk_abc_sys"] + pub fn Vec_PtrAppend(vVec1: *mut Vec_Ptr_t, vVec2: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrPushFirst_imctk_abc_sys"] + pub fn Vec_PtrPushFirst(p: *mut Vec_Ptr_t, Entry: *mut ::std::os::raw::c_void); +} +extern "C" { + #[link_name = "Vec_PtrPushUnique_imctk_abc_sys"] + pub fn Vec_PtrPushUnique( + p: *mut Vec_Ptr_t, + Entry: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrPop_imctk_abc_sys"] + pub fn Vec_PtrPop(p: *mut Vec_Ptr_t) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_PtrFind_imctk_abc_sys"] + pub fn Vec_PtrFind( + p: *mut Vec_Ptr_t, + Entry: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrFindStr_imctk_abc_sys"] + pub fn Vec_PtrFindStr( + p: *mut Vec_Ptr_t, + Entry: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrRemove_imctk_abc_sys"] + pub fn Vec_PtrRemove(p: *mut Vec_Ptr_t, Entry: *mut ::std::os::raw::c_void); +} +extern "C" { + #[link_name = "Vec_PtrDrop_imctk_abc_sys"] + pub fn Vec_PtrDrop(p: *mut Vec_Ptr_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_PtrInsert_imctk_abc_sys"] + pub fn Vec_PtrInsert( + p: *mut Vec_Ptr_t, + iHere: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_PtrReorder_imctk_abc_sys"] + pub fn Vec_PtrReorder(p: *mut Vec_Ptr_t, nItems: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_PtrReverseOrder_imctk_abc_sys"] + pub fn Vec_PtrReverseOrder(p: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrEqual_imctk_abc_sys"] + pub fn Vec_PtrEqual(p1: *mut Vec_Ptr_t, p2: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrSortComparePtr_imctk_abc_sys"] + pub fn Vec_PtrSortComparePtr( + pp1: *mut *mut ::std::os::raw::c_void, + pp2: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrSort_imctk_abc_sys"] + pub fn Vec_PtrSort( + p: *mut Vec_Ptr_t, + Vec_PtrSortCompare: ::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 = "Vec_PtrUniqify_imctk_abc_sys"] + pub fn Vec_PtrUniqify( + p: *mut Vec_Ptr_t, + Vec_PtrSortCompare: ::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 = "Vec_PtrUniqify2_imctk_abc_sys"] + pub fn Vec_PtrUniqify2( + p: *mut Vec_Ptr_t, + Vec_PtrSortCompare: ::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, + >, + Vec_PtrObjFree: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void), + >, + vCounts: *mut Vec_Int_t, + ); +} +extern "C" { + #[link_name = "Vec_PtrAllocSimInfo_imctk_abc_sys"] + pub fn Vec_PtrAllocSimInfo( + nEntries: ::std::os::raw::c_int, + nWords: ::std::os::raw::c_int, + ) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_PtrReadWordsSimInfo_imctk_abc_sys"] + pub fn Vec_PtrReadWordsSimInfo(p: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_PtrCleanSimInfo_imctk_abc_sys"] + pub fn Vec_PtrCleanSimInfo( + vInfo: *mut Vec_Ptr_t, + iWord: ::std::os::raw::c_int, + nWords: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_PtrFillSimInfo_imctk_abc_sys"] + pub fn Vec_PtrFillSimInfo( + vInfo: *mut Vec_Ptr_t, + iWord: ::std::os::raw::c_int, + nWords: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_PtrDoubleSimInfo_imctk_abc_sys"] + pub fn Vec_PtrDoubleSimInfo(vInfo: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrReallocSimInfo_imctk_abc_sys"] + pub fn Vec_PtrReallocSimInfo(vInfo: *mut Vec_Ptr_t); +} +extern "C" { + #[link_name = "Vec_PtrAllocTruthTables_imctk_abc_sys"] + pub fn Vec_PtrAllocTruthTables(nVars: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +pub type Vec_Vec_t = Vec_Vec_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Vec_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_Vec_Vec_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Vec_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Vec_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Vec_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Vec_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Vec_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_VecAlloc_imctk_abc_sys"] + pub fn Vec_VecAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Vec_t; +} +extern "C" { + #[link_name = "Vec_VecStart_imctk_abc_sys"] + pub fn Vec_VecStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Vec_t; +} +extern "C" { + #[link_name = "Vec_VecExpand_imctk_abc_sys"] + pub fn Vec_VecExpand(p: *mut Vec_Vec_t, Level: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_VecExpandInt_imctk_abc_sys"] + pub fn Vec_VecExpandInt(p: *mut Vec_Vec_t, Level: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_VecSize_imctk_abc_sys"] + pub fn Vec_VecSize(p: *mut Vec_Vec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecCap_imctk_abc_sys"] + pub fn Vec_VecCap(p: *mut Vec_Vec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecLevelSize_imctk_abc_sys"] + pub fn Vec_VecLevelSize(p: *mut Vec_Vec_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecEntry_imctk_abc_sys"] + pub fn Vec_VecEntry(p: *mut Vec_Vec_t, i: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_VecEntryInt_imctk_abc_sys"] + pub fn Vec_VecEntryInt(p: *mut Vec_Vec_t, i: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_VecMemory_imctk_abc_sys"] + pub fn Vec_VecMemory(p: *mut Vec_Vec_t) -> f64; +} +extern "C" { + #[link_name = "Vec_VecMemoryInt_imctk_abc_sys"] + pub fn Vec_VecMemoryInt(p: *mut Vec_Vec_t) -> f64; +} +extern "C" { + #[link_name = "Vec_VecEntryEntry_imctk_abc_sys"] + pub fn Vec_VecEntryEntry( + p: *mut Vec_Vec_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_VecEntryEntryInt_imctk_abc_sys"] + pub fn Vec_VecEntryEntryInt( + p: *mut Vec_Vec_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecFree_imctk_abc_sys"] + pub fn Vec_VecFree(p: *mut Vec_Vec_t); +} +extern "C" { + #[link_name = "Vec_VecErase_imctk_abc_sys"] + pub fn Vec_VecErase(p: *mut Vec_Vec_t); +} +extern "C" { + #[link_name = "Vec_VecFreeP_imctk_abc_sys"] + pub fn Vec_VecFreeP(p: *mut *mut Vec_Vec_t); +} +extern "C" { + #[link_name = "Vec_VecDup_imctk_abc_sys"] + pub fn Vec_VecDup(p: *mut Vec_Vec_t) -> *mut Vec_Vec_t; +} +extern "C" { + #[link_name = "Vec_VecDupInt_imctk_abc_sys"] + pub fn Vec_VecDupInt(p: *mut Vec_Vec_t) -> *mut Vec_Vec_t; +} +extern "C" { + #[link_name = "Vec_VecSizeSize_imctk_abc_sys"] + pub fn Vec_VecSizeSize(p: *mut Vec_Vec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecClear_imctk_abc_sys"] + pub fn Vec_VecClear(p: *mut Vec_Vec_t); +} +extern "C" { + #[link_name = "Vec_VecPush_imctk_abc_sys"] + pub fn Vec_VecPush( + p: *mut Vec_Vec_t, + Level: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_VecPushInt_imctk_abc_sys"] + pub fn Vec_VecPushInt( + p: *mut Vec_Vec_t, + Level: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_VecPushUnique_imctk_abc_sys"] + pub fn Vec_VecPushUnique( + p: *mut Vec_Vec_t, + Level: ::std::os::raw::c_int, + Entry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_VecPushUniqueInt_imctk_abc_sys"] + pub fn Vec_VecPushUniqueInt( + p: *mut Vec_Vec_t, + Level: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_VecSortCompare1_imctk_abc_sys"] + pub fn Vec_VecSortCompare1( + pp1: *mut *mut Vec_Ptr_t, + pp2: *mut *mut Vec_Ptr_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecSortCompare2_imctk_abc_sys"] + pub fn Vec_VecSortCompare2( + pp1: *mut *mut Vec_Ptr_t, + pp2: *mut *mut Vec_Ptr_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecSort_imctk_abc_sys"] + pub fn Vec_VecSort(p: *mut Vec_Vec_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_VecSortCompare3_imctk_abc_sys"] + pub fn Vec_VecSortCompare3( + pp1: *mut *mut Vec_Int_t, + pp2: *mut *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecSortCompare4_imctk_abc_sys"] + pub fn Vec_VecSortCompare4( + pp1: *mut *mut Vec_Int_t, + pp2: *mut *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_VecSortByFirstInt_imctk_abc_sys"] + pub fn Vec_VecSortByFirstInt(p: *mut Vec_Vec_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_VecPrintInt_imctk_abc_sys"] + pub fn Vec_VecPrintInt(p: *mut Vec_Vec_t, fSkipSingles: ::std::os::raw::c_int); +} +pub const Vec_AttrType_t_VEC_ATTR_NONE: Vec_AttrType_t = 0; +pub const Vec_AttrType_t_VEC_ATTR_COPY: Vec_AttrType_t = 1; +pub const Vec_AttrType_t_VEC_ATTR_LOCAL_AIG: Vec_AttrType_t = 2; +pub const Vec_AttrType_t_VEC_ATTR_LOCAL_SOP: Vec_AttrType_t = 3; +pub const Vec_AttrType_t_VEC_ATTR_LOCAL_BDD: Vec_AttrType_t = 4; +pub const Vec_AttrType_t_VEC_ATTR_GLOBAL_AIG: Vec_AttrType_t = 5; +pub const Vec_AttrType_t_VEC_ATTR_GLOBAL_SOP: Vec_AttrType_t = 6; +pub const Vec_AttrType_t_VEC_ATTR_GLOBAL_BDD: Vec_AttrType_t = 7; +pub const Vec_AttrType_t_VEC_ATTR_LEVEL: Vec_AttrType_t = 8; +pub const Vec_AttrType_t_VEC_ATTR_LEVEL_REV: Vec_AttrType_t = 9; +pub const Vec_AttrType_t_VEC_ATTR_RETIME_LAG: Vec_AttrType_t = 10; +pub const Vec_AttrType_t_VEC_ATTR_FRAIG: Vec_AttrType_t = 11; +pub const Vec_AttrType_t_VEC_ATTR_MVVAR: Vec_AttrType_t = 12; +pub const Vec_AttrType_t_VEC_ATTR_DATA1: Vec_AttrType_t = 13; +pub const Vec_AttrType_t_VEC_ATTR_DATA2: Vec_AttrType_t = 14; +pub const Vec_AttrType_t_VEC_ATTR_TOTAL_NUM: Vec_AttrType_t = 15; +pub type Vec_AttrType_t = ::std::os::raw::c_uint; +pub type Vec_Att_t = Vec_Att_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Att_t_ { + pub nCap: ::std::os::raw::c_int, + pub pArrayPtr: *mut *mut ::std::os::raw::c_void, + pub pMan: *mut ::std::os::raw::c_void, + pub pFuncFreeMan: + ::std::option::Option, + pub pFuncStartObj: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void, + >, + pub pFuncFreeObj: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_void), + >, +} +#[test] +fn bindgen_test_layout_Vec_Att_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Vec_Att_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Att_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArrayPtr) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(pArrayPtr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pMan) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(pMan) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pFuncFreeMan) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(pFuncFreeMan) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pFuncStartObj) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(pFuncStartObj) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pFuncFreeObj) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Vec_Att_t_), + "::", + stringify!(pFuncFreeObj) + ) + ); +} +extern "C" { + #[link_name = "Vec_AttAlloc_imctk_abc_sys"] + pub fn Vec_AttAlloc( + nSize: ::std::os::raw::c_int, + pMan: *mut ::std::os::raw::c_void, + pFuncFreeMan: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void), + >, + pFuncStartObj: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void, + >, + pFuncFreeObj: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut ::std::os::raw::c_void, + ), + >, + ) -> *mut Vec_Att_t; +} +extern "C" { + #[link_name = "Vec_AttFree_imctk_abc_sys"] + pub fn Vec_AttFree( + p: *mut Vec_Att_t, + fFreeMan: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_AttClear_imctk_abc_sys"] + pub fn Vec_AttClear(p: *mut Vec_Att_t); +} +extern "C" { + #[link_name = "Vec_AttFreeEntry_imctk_abc_sys"] + pub fn Vec_AttFreeEntry(p: *mut Vec_Att_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_AttGrow_imctk_abc_sys"] + pub fn Vec_AttGrow(p: *mut Vec_Att_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_AttWriteEntry_imctk_abc_sys"] + pub fn Vec_AttWriteEntry( + p: *mut Vec_Att_t, + i: ::std::os::raw::c_int, + pEntry: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + #[link_name = "Vec_AttEntry_imctk_abc_sys"] + pub fn Vec_AttEntry(p: *mut Vec_Att_t, i: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_AttMan_imctk_abc_sys"] + pub fn Vec_AttMan(p: *mut Vec_Att_t) -> *mut ::std::os::raw::c_void; +} +extern "C" { + #[link_name = "Vec_AttArray_imctk_abc_sys"] + pub fn Vec_AttArray(p: *mut Vec_Att_t) -> *mut *mut ::std::os::raw::c_void; +} +pub type Vec_Wrd_t = Vec_Wrd_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Wrd_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut word, +} +#[test] +fn bindgen_test_layout_Vec_Wrd_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Wrd_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Wrd_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wrd_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wrd_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wrd_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_WrdAlloc_imctk_abc_sys"] + pub fn Vec_WrdAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdAllocExact_imctk_abc_sys"] + pub fn Vec_WrdAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStart_imctk_abc_sys"] + pub fn Vec_WrdStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStartFull_imctk_abc_sys"] + pub fn Vec_WrdStartFull(nSize: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStartNatural_imctk_abc_sys"] + pub fn Vec_WrdStartNatural(nSize: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStartRandom_imctk_abc_sys"] + pub fn Vec_WrdStartRandom(nSize: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStartTruthTables_imctk_abc_sys"] + pub fn Vec_WrdStartTruthTables(nVars: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdStartTruthTablesRev_imctk_abc_sys"] + pub fn Vec_WrdStartTruthTablesRev(nVars: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdShiftOne_imctk_abc_sys"] + pub fn Vec_WrdShiftOne( + p: *mut Vec_Wrd_t, + nWords: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdAllocArray_imctk_abc_sys"] + pub fn Vec_WrdAllocArray(pArray: *mut word, nSize: ::std::os::raw::c_int) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdAllocArrayCopy_imctk_abc_sys"] + pub fn Vec_WrdAllocArrayCopy(pArray: *mut word, nSize: ::std::os::raw::c_int) + -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdDup_imctk_abc_sys"] + pub fn Vec_WrdDup(pVec: *mut Vec_Wrd_t) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdDupArray_imctk_abc_sys"] + pub fn Vec_WrdDupArray(pVec: *mut Vec_Wrd_t) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdErase_imctk_abc_sys"] + pub fn Vec_WrdErase(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdFree_imctk_abc_sys"] + pub fn Vec_WrdFree(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdFreeP_imctk_abc_sys"] + pub fn Vec_WrdFreeP(p: *mut *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdReleaseArray_imctk_abc_sys"] + pub fn Vec_WrdReleaseArray(p: *mut Vec_Wrd_t) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdArray_imctk_abc_sys"] + pub fn Vec_WrdArray(p: *mut Vec_Wrd_t) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdLimit_imctk_abc_sys"] + pub fn Vec_WrdLimit(p: *mut Vec_Wrd_t) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdSize_imctk_abc_sys"] + pub fn Vec_WrdSize(p: *mut Vec_Wrd_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdChangeSize_imctk_abc_sys"] + pub fn Vec_WrdChangeSize( + p: *mut Vec_Wrd_t, + Shift: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdCap_imctk_abc_sys"] + pub fn Vec_WrdCap(p: *mut Vec_Wrd_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdMemory_imctk_abc_sys"] + pub fn Vec_WrdMemory(p: *mut Vec_Wrd_t) -> f64; +} +extern "C" { + #[link_name = "Vec_WrdEntry_imctk_abc_sys"] + pub fn Vec_WrdEntry(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int) -> word; +} +extern "C" { + #[link_name = "Vec_WrdEntryP_imctk_abc_sys"] + pub fn Vec_WrdEntryP(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdWriteEntry_imctk_abc_sys"] + pub fn Vec_WrdWriteEntry(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdAddToEntry_imctk_abc_sys"] + pub fn Vec_WrdAddToEntry(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int, Addition: word) -> word; +} +extern "C" { + #[link_name = "Vec_WrdEntryLast_imctk_abc_sys"] + pub fn Vec_WrdEntryLast(p: *mut Vec_Wrd_t) -> word; +} +extern "C" { + #[link_name = "Vec_WrdGrow_imctk_abc_sys"] + pub fn Vec_WrdGrow(p: *mut Vec_Wrd_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdFill_imctk_abc_sys"] + pub fn Vec_WrdFill(p: *mut Vec_Wrd_t, nSize: ::std::os::raw::c_int, Fill: word); +} +extern "C" { + #[link_name = "Vec_WrdFillExtra_imctk_abc_sys"] + pub fn Vec_WrdFillExtra(p: *mut Vec_Wrd_t, nSize: ::std::os::raw::c_int, Fill: word); +} +extern "C" { + #[link_name = "Vec_WrdGetEntry_imctk_abc_sys"] + pub fn Vec_WrdGetEntry(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int) -> word; +} +extern "C" { + #[link_name = "Vec_WrdGetEntryP_imctk_abc_sys"] + pub fn Vec_WrdGetEntryP(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdSetEntry_imctk_abc_sys"] + pub fn Vec_WrdSetEntry(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdShrink_imctk_abc_sys"] + pub fn Vec_WrdShrink(p: *mut Vec_Wrd_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdClear_imctk_abc_sys"] + pub fn Vec_WrdClear(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdPush_imctk_abc_sys"] + pub fn Vec_WrdPush(p: *mut Vec_Wrd_t, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdPushTwo_imctk_abc_sys"] + pub fn Vec_WrdPushTwo(p: *mut Vec_Wrd_t, Entry1: word, Entry2: word); +} +extern "C" { + #[link_name = "Vec_WrdPushThree_imctk_abc_sys"] + pub fn Vec_WrdPushThree(p: *mut Vec_Wrd_t, Entry1: word, Entry2: word, Entry3: word); +} +extern "C" { + #[link_name = "Vec_WrdPushFour_imctk_abc_sys"] + pub fn Vec_WrdPushFour( + p: *mut Vec_Wrd_t, + Entry1: word, + Entry2: word, + Entry3: word, + Entry4: word, + ); +} +extern "C" { + #[link_name = "Vec_WrdPushArray_imctk_abc_sys"] + pub fn Vec_WrdPushArray( + p: *mut Vec_Wrd_t, + pEntries: *mut word, + nEntries: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WrdPushFirst_imctk_abc_sys"] + pub fn Vec_WrdPushFirst(p: *mut Vec_Wrd_t, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdPushOrder_imctk_abc_sys"] + pub fn Vec_WrdPushOrder(p: *mut Vec_Wrd_t, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdPushUniqueOrder_imctk_abc_sys"] + pub fn Vec_WrdPushUniqueOrder(p: *mut Vec_Wrd_t, Entry: word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdPushUnique_imctk_abc_sys"] + pub fn Vec_WrdPushUnique(p: *mut Vec_Wrd_t, Entry: word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdFetch_imctk_abc_sys"] + pub fn Vec_WrdFetch(p: *mut Vec_Wrd_t, nWords: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Vec_WrdPop_imctk_abc_sys"] + pub fn Vec_WrdPop(p: *mut Vec_Wrd_t) -> word; +} +extern "C" { + #[link_name = "Vec_WrdFind_imctk_abc_sys"] + pub fn Vec_WrdFind(p: *mut Vec_Wrd_t, Entry: word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdRemove_imctk_abc_sys"] + pub fn Vec_WrdRemove(p: *mut Vec_Wrd_t, Entry: word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdInsert_imctk_abc_sys"] + pub fn Vec_WrdInsert(p: *mut Vec_Wrd_t, iHere: ::std::os::raw::c_int, Entry: word); +} +extern "C" { + #[link_name = "Vec_WrdDrop_imctk_abc_sys"] + pub fn Vec_WrdDrop(p: *mut Vec_Wrd_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdFindMax_imctk_abc_sys"] + pub fn Vec_WrdFindMax(p: *mut Vec_Wrd_t) -> word; +} +extern "C" { + #[link_name = "Vec_WrdFindMin_imctk_abc_sys"] + pub fn Vec_WrdFindMin(p: *mut Vec_Wrd_t) -> word; +} +extern "C" { + #[link_name = "Vec_WrdReverseOrder_imctk_abc_sys"] + pub fn Vec_WrdReverseOrder(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdInvert_imctk_abc_sys"] + pub fn Vec_WrdInvert(p: *mut Vec_Wrd_t, Fill: word) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdSum_imctk_abc_sys"] + pub fn Vec_WrdSum(p: *mut Vec_Wrd_t) -> word; +} +extern "C" { + #[link_name = "Vec_WrdCountZero_imctk_abc_sys"] + pub fn Vec_WrdCountZero(p: *mut Vec_Wrd_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdEqual_imctk_abc_sys"] + pub fn Vec_WrdEqual(p1: *mut Vec_Wrd_t, p2: *mut Vec_Wrd_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdCountCommon_imctk_abc_sys"] + pub fn Vec_WrdCountCommon(p1: *mut Vec_Wrd_t, p2: *mut Vec_Wrd_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdSortCompare1_imctk_abc_sys"] + pub fn Vec_WrdSortCompare1(pp1: *mut word, pp2: *mut word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdSortCompare2_imctk_abc_sys"] + pub fn Vec_WrdSortCompare2(pp1: *mut word, pp2: *mut word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdSort_imctk_abc_sys"] + pub fn Vec_WrdSort(p: *mut Vec_Wrd_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdUniqify_imctk_abc_sys"] + pub fn Vec_WrdUniqify(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdUniqueCount_imctk_abc_sys"] + pub fn Vec_WrdUniqueCount( + vData: *mut Vec_Wrd_t, + nWordSize: ::std::os::raw::c_int, + pvMap: *mut *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdUniqifyHash_imctk_abc_sys"] + pub fn Vec_WrdUniqifyHash( + vData: *mut Vec_Wrd_t, + nWordSize: ::std::os::raw::c_int, + ) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdTwoCountCommon_imctk_abc_sys"] + pub fn Vec_WrdTwoCountCommon( + vArr1: *mut Vec_Wrd_t, + vArr2: *mut Vec_Wrd_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdSortCompareUnsigned_imctk_abc_sys"] + pub fn Vec_WrdSortCompareUnsigned(pp1: *mut word, pp2: *mut word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdSortUnsigned_imctk_abc_sys"] + pub fn Vec_WrdSortUnsigned(p: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdAppend_imctk_abc_sys"] + pub fn Vec_WrdAppend(vVec1: *mut Vec_Wrd_t, vVec2: *mut Vec_Wrd_t); +} +extern "C" { + #[link_name = "Vec_WrdDumpBoolOne_imctk_abc_sys"] + pub fn Vec_WrdDumpBoolOne( + pFile: *mut FILE, + pSim: *mut word, + nBits: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WrdDumpBool_imctk_abc_sys"] + pub fn Vec_WrdDumpBool( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Wrd_t, + nWords: ::std::os::raw::c_int, + nBits: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WrdDumpHexOne_imctk_abc_sys"] + pub fn Vec_WrdDumpHexOne(pFile: *mut FILE, pSim: *mut word, nWords: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdPrintHex_imctk_abc_sys"] + pub fn Vec_WrdPrintHex(p: *mut Vec_Wrd_t, nWords: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WrdDumpHex_imctk_abc_sys"] + pub fn Vec_WrdDumpHex( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Wrd_t, + nWords: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WrdReadHexOne_imctk_abc_sys"] + pub fn Vec_WrdReadHexOne(c: ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WrdReadHex_imctk_abc_sys"] + pub fn Vec_WrdReadHex( + pFileName: *mut ::std::os::raw::c_char, + pnWords: *mut ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Wrd_t; +} +extern "C" { + #[link_name = "Vec_WrdDumpBin_imctk_abc_sys"] + pub fn Vec_WrdDumpBin( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Wrd_t, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WrdReadBin_imctk_abc_sys"] + pub fn Vec_WrdReadBin( + pFileName: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Wrd_t; +} +pub type Vec_Bit_t = Vec_Bit_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Bit_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Vec_Bit_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Bit_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Bit_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Bit_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Bit_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Bit_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_BitAlloc_imctk_abc_sys"] + pub fn Vec_BitAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Bit_t; +} +extern "C" { + #[link_name = "Vec_BitStart_imctk_abc_sys"] + pub fn Vec_BitStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Bit_t; +} +extern "C" { + #[link_name = "Vec_BitStartFull_imctk_abc_sys"] + pub fn Vec_BitStartFull(nSize: ::std::os::raw::c_int) -> *mut Vec_Bit_t; +} +extern "C" { + #[link_name = "Vec_BitDup_imctk_abc_sys"] + pub fn Vec_BitDup(pVec: *mut Vec_Bit_t) -> *mut Vec_Bit_t; +} +extern "C" { + #[link_name = "Vec_BitFree_imctk_abc_sys"] + pub fn Vec_BitFree(p: *mut Vec_Bit_t); +} +extern "C" { + #[link_name = "Vec_BitFreeP_imctk_abc_sys"] + pub fn Vec_BitFreeP(p: *mut *mut Vec_Bit_t); +} +extern "C" { + #[link_name = "Vec_BitReleaseArray_imctk_abc_sys"] + pub fn Vec_BitReleaseArray(p: *mut Vec_Bit_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitArray_imctk_abc_sys"] + pub fn Vec_BitArray(p: *mut Vec_Bit_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitSize_imctk_abc_sys"] + pub fn Vec_BitSize(p: *mut Vec_Bit_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitCap_imctk_abc_sys"] + pub fn Vec_BitCap(p: *mut Vec_Bit_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitMemory_imctk_abc_sys"] + pub fn Vec_BitMemory(p: *mut Vec_Bit_t) -> f64; +} +extern "C" { + #[link_name = "Vec_BitEntry_imctk_abc_sys"] + pub fn Vec_BitEntry(p: *mut Vec_Bit_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitWriteEntry_imctk_abc_sys"] + pub fn Vec_BitWriteEntry( + p: *mut Vec_Bit_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_BitAddEntry_imctk_abc_sys"] + pub fn Vec_BitAddEntry(p: *mut Vec_Bit_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitEntryLast_imctk_abc_sys"] + pub fn Vec_BitEntryLast(p: *mut Vec_Bit_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitGrow_imctk_abc_sys"] + pub fn Vec_BitGrow(p: *mut Vec_Bit_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_BitFill_imctk_abc_sys"] + pub fn Vec_BitFill( + p: *mut Vec_Bit_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_BitFillExtra_imctk_abc_sys"] + pub fn Vec_BitFillExtra( + p: *mut Vec_Bit_t, + nSize: ::std::os::raw::c_int, + Fill: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_BitGetEntry_imctk_abc_sys"] + pub fn Vec_BitGetEntry(p: *mut Vec_Bit_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitSetEntry_imctk_abc_sys"] + pub fn Vec_BitSetEntry( + p: *mut Vec_Bit_t, + i: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_BitShrink_imctk_abc_sys"] + pub fn Vec_BitShrink(p: *mut Vec_Bit_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_BitClear_imctk_abc_sys"] + pub fn Vec_BitClear(p: *mut Vec_Bit_t); +} +extern "C" { + #[link_name = "Vec_BitPush_imctk_abc_sys"] + pub fn Vec_BitPush(p: *mut Vec_Bit_t, Entry: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_BitPop_imctk_abc_sys"] + pub fn Vec_BitPop(p: *mut Vec_Bit_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitCountWord_imctk_abc_sys"] + pub fn Vec_BitCountWord(uWord: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitCount_imctk_abc_sys"] + pub fn Vec_BitCount(p: *mut Vec_Bit_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_BitReset_imctk_abc_sys"] + pub fn Vec_BitReset(p: *mut Vec_Bit_t); +} +extern "C" { + #[link_name = "Vec_BitPrint_imctk_abc_sys"] + pub fn Vec_BitPrint(p: *mut Vec_Bit_t); +} +pub type Vec_Mem_t = Vec_Mem_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Mem_t_ { + pub nEntrySize: ::std::os::raw::c_int, + pub nEntries: ::std::os::raw::c_int, + pub LogPageSze: ::std::os::raw::c_int, + pub PageMask: ::std::os::raw::c_int, + pub nPageAlloc: ::std::os::raw::c_int, + pub iPage: ::std::os::raw::c_int, + pub ppPages: *mut *mut word, + pub vTable: *mut Vec_Int_t, + pub vNexts: *mut Vec_Int_t, +} +#[test] +fn bindgen_test_layout_Vec_Mem_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Vec_Mem_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Mem_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nEntrySize) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(nEntrySize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nEntries) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(nEntries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).LogPageSze) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(LogPageSze) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PageMask) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(PageMask) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nPageAlloc) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(nPageAlloc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iPage) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(iPage) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ppPages) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(ppPages) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTable) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(vTable) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vNexts) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Vec_Mem_t_), + "::", + stringify!(vNexts) + ) + ); +} +extern "C" { + #[link_name = "Vec_MemAlloc__imctk_abc_sys"] + pub fn Vec_MemAlloc_( + p: *mut Vec_Mem_t, + nEntrySize: ::std::os::raw::c_int, + LogPageSze: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_MemAlloc_imctk_abc_sys"] + pub fn Vec_MemAlloc( + nEntrySize: ::std::os::raw::c_int, + LogPageSze: ::std::os::raw::c_int, + ) -> *mut Vec_Mem_t; +} +extern "C" { + #[link_name = "Vec_MemFree_imctk_abc_sys"] + pub fn Vec_MemFree(p: *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemFreeP_imctk_abc_sys"] + pub fn Vec_MemFreeP(p: *mut *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemDup_imctk_abc_sys"] + pub fn Vec_MemDup(pVec: *mut Vec_Mem_t) -> *mut Vec_Mem_t; +} +extern "C" { + #[link_name = "Vec_MemFill_imctk_abc_sys"] + pub fn Vec_MemFill(pVec: *mut Vec_Mem_t, nEntries: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemClean_imctk_abc_sys"] + pub fn Vec_MemClean(pVec: *mut Vec_Mem_t, nEntries: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemEntrySize_imctk_abc_sys"] + pub fn Vec_MemEntrySize(p: *mut Vec_Mem_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemEntryNum_imctk_abc_sys"] + pub fn Vec_MemEntryNum(p: *mut Vec_Mem_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemPageSize_imctk_abc_sys"] + pub fn Vec_MemPageSize(p: *mut Vec_Mem_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemPageNum_imctk_abc_sys"] + pub fn Vec_MemPageNum(p: *mut Vec_Mem_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemMemory_imctk_abc_sys"] + pub fn Vec_MemMemory(p: *mut Vec_Mem_t) -> f64; +} +extern "C" { + #[link_name = "Vec_MemReadEntry_imctk_abc_sys"] + pub fn Vec_MemReadEntry(p: *mut Vec_Mem_t, i: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Vec_MemReadEntryLast_imctk_abc_sys"] + pub fn Vec_MemReadEntryLast(p: *mut Vec_Mem_t) -> *mut word; +} +extern "C" { + #[link_name = "Vec_MemWriteEntry_imctk_abc_sys"] + pub fn Vec_MemWriteEntry(p: *mut Vec_Mem_t, i: ::std::os::raw::c_int, pEntry: *mut word); +} +extern "C" { + #[link_name = "Vec_MemGetEntry_imctk_abc_sys"] + pub fn Vec_MemGetEntry(p: *mut Vec_Mem_t, i: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Vec_MemSetEntry_imctk_abc_sys"] + pub fn Vec_MemSetEntry(p: *mut Vec_Mem_t, i: ::std::os::raw::c_int, pEntry: *mut word); +} +extern "C" { + #[link_name = "Vec_MemPush_imctk_abc_sys"] + pub fn Vec_MemPush(p: *mut Vec_Mem_t, pEntry: *mut word); +} +extern "C" { + #[link_name = "Vec_MemShrink_imctk_abc_sys"] + pub fn Vec_MemShrink(p: *mut Vec_Mem_t, nEntriesNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemDumpDigit_imctk_abc_sys"] + pub fn Vec_MemDumpDigit(pFile: *mut FILE, HexDigit: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemDump_imctk_abc_sys"] + pub fn Vec_MemDump(pFile: *mut FILE, pVec: *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemHashAlloc_imctk_abc_sys"] + pub fn Vec_MemHashAlloc(p: *mut Vec_Mem_t, nTableSize: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemHashFree_imctk_abc_sys"] + pub fn Vec_MemHashFree(p: *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemHashKey_imctk_abc_sys"] + pub fn Vec_MemHashKey(p: *mut Vec_Mem_t, pEntry: *mut word) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Vec_MemHashLookup_imctk_abc_sys"] + pub fn Vec_MemHashLookup(p: *mut Vec_Mem_t, pEntry: *mut word) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemHashProfile_imctk_abc_sys"] + pub fn Vec_MemHashProfile(p: *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemHashResize_imctk_abc_sys"] + pub fn Vec_MemHashResize(p: *mut Vec_Mem_t); +} +extern "C" { + #[link_name = "Vec_MemHashInsert_imctk_abc_sys"] + pub fn Vec_MemHashInsert(p: *mut Vec_Mem_t, pEntry: *mut word) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_MemAllocForTTSimple_imctk_abc_sys"] + pub fn Vec_MemAllocForTTSimple(nVars: ::std::os::raw::c_int) -> *mut Vec_Mem_t; +} +extern "C" { + #[link_name = "Vec_MemAllocForTT_imctk_abc_sys"] + pub fn Vec_MemAllocForTT( + nVars: ::std::os::raw::c_int, + fCompl: ::std::os::raw::c_int, + ) -> *mut Vec_Mem_t; +} +extern "C" { + #[link_name = "Vec_MemAddMuxTT_imctk_abc_sys"] + pub fn Vec_MemAddMuxTT(p: *mut Vec_Mem_t, nVars: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_MemDumpTruthTables_imctk_abc_sys"] + pub fn Vec_MemDumpTruthTables( + p: *mut Vec_Mem_t, + pName: *mut ::std::os::raw::c_char, + nLutSize: ::std::os::raw::c_int, + ); +} +pub type Vec_Wec_t = Vec_Wec_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Vec_Wec_t_ { + pub nCap: ::std::os::raw::c_int, + pub nSize: ::std::os::raw::c_int, + pub pArray: *mut Vec_Int_t, +} +#[test] +fn bindgen_test_layout_Vec_Wec_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Vec_Wec_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Vec_Wec_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCap) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wec_t_), + "::", + stringify!(nCap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSize) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wec_t_), + "::", + stringify!(nSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pArray) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Vec_Wec_t_), + "::", + stringify!(pArray) + ) + ); +} +extern "C" { + #[link_name = "Vec_WecAlloc_imctk_abc_sys"] + pub fn Vec_WecAlloc(nCap: ::std::os::raw::c_int) -> *mut Vec_Wec_t; +} +extern "C" { + #[link_name = "Vec_WecAllocExact_imctk_abc_sys"] + pub fn Vec_WecAllocExact(nCap: ::std::os::raw::c_int) -> *mut Vec_Wec_t; +} +extern "C" { + #[link_name = "Vec_WecStart_imctk_abc_sys"] + pub fn Vec_WecStart(nSize: ::std::os::raw::c_int) -> *mut Vec_Wec_t; +} +extern "C" { + #[link_name = "Vec_WecGrow_imctk_abc_sys"] + pub fn Vec_WecGrow(p: *mut Vec_Wec_t, nCapMin: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecInit_imctk_abc_sys"] + pub fn Vec_WecInit(p: *mut Vec_Wec_t, nSize: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecEntry_imctk_abc_sys"] + pub fn Vec_WecEntry(p: *mut Vec_Wec_t, i: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecEntryLast_imctk_abc_sys"] + pub fn Vec_WecEntryLast(p: *mut Vec_Wec_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecEntryEntry_imctk_abc_sys"] + pub fn Vec_WecEntryEntry( + p: *mut Vec_Wec_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecArray_imctk_abc_sys"] + pub fn Vec_WecArray(p: *mut Vec_Wec_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecLevelId_imctk_abc_sys"] + pub fn Vec_WecLevelId(p: *mut Vec_Wec_t, vLevel: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecCap_imctk_abc_sys"] + pub fn Vec_WecCap(p: *mut Vec_Wec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSize_imctk_abc_sys"] + pub fn Vec_WecSize(p: *mut Vec_Wec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecLevelSize_imctk_abc_sys"] + pub fn Vec_WecLevelSize(p: *mut Vec_Wec_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSizeSize_imctk_abc_sys"] + pub fn Vec_WecSizeSize(p: *mut Vec_Wec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSizeUsed_imctk_abc_sys"] + pub fn Vec_WecSizeUsed(p: *mut Vec_Wec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSizeUsedLimits_imctk_abc_sys"] + pub fn Vec_WecSizeUsedLimits( + p: *mut Vec_Wec_t, + iStart: ::std::os::raw::c_int, + iStop: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecShrink_imctk_abc_sys"] + pub fn Vec_WecShrink(p: *mut Vec_Wec_t, nSizeNew: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecClear_imctk_abc_sys"] + pub fn Vec_WecClear(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecClearLevels_imctk_abc_sys"] + pub fn Vec_WecClearLevels(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecPush_imctk_abc_sys"] + pub fn Vec_WecPush( + p: *mut Vec_Wec_t, + Level: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WecPushTwo_imctk_abc_sys"] + pub fn Vec_WecPushTwo( + p: *mut Vec_Wec_t, + Level: ::std::os::raw::c_int, + Entry1: ::std::os::raw::c_int, + Entry2: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WecPushLevel_imctk_abc_sys"] + pub fn Vec_WecPushLevel(p: *mut Vec_Wec_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecInsertLevel_imctk_abc_sys"] + pub fn Vec_WecInsertLevel(p: *mut Vec_Wec_t, i: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecMemory_imctk_abc_sys"] + pub fn Vec_WecMemory(p: *mut Vec_Wec_t) -> f64; +} +extern "C" { + #[link_name = "Vec_WecZero_imctk_abc_sys"] + pub fn Vec_WecZero(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecErase_imctk_abc_sys"] + pub fn Vec_WecErase(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecFree_imctk_abc_sys"] + pub fn Vec_WecFree(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecFreeP_imctk_abc_sys"] + pub fn Vec_WecFreeP(p: *mut *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecPushUnique_imctk_abc_sys"] + pub fn Vec_WecPushUnique( + p: *mut Vec_Wec_t, + Level: ::std::os::raw::c_int, + Entry: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WecDup_imctk_abc_sys"] + pub fn Vec_WecDup(p: *mut Vec_Wec_t) -> *mut Vec_Wec_t; +} +extern "C" { + #[link_name = "Vec_WecSortCompare1_imctk_abc_sys"] + pub fn Vec_WecSortCompare1(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSortCompare2_imctk_abc_sys"] + pub fn Vec_WecSortCompare2(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSort_imctk_abc_sys"] + pub fn Vec_WecSort(p: *mut Vec_Wec_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecSortCompare3_imctk_abc_sys"] + pub fn Vec_WecSortCompare3(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSortCompare4_imctk_abc_sys"] + pub fn Vec_WecSortCompare4(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSortByFirstInt_imctk_abc_sys"] + pub fn Vec_WecSortByFirstInt(p: *mut Vec_Wec_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecSortCompare5_imctk_abc_sys"] + pub fn Vec_WecSortCompare5(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSortCompare6_imctk_abc_sys"] + pub fn Vec_WecSortCompare6(p1: *mut Vec_Int_t, p2: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecSortByLastInt_imctk_abc_sys"] + pub fn Vec_WecSortByLastInt(p: *mut Vec_Wec_t, fReverse: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecKeepLevels_imctk_abc_sys"] + pub fn Vec_WecKeepLevels(p: *mut Vec_Wec_t, Limit: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecPrint_imctk_abc_sys"] + pub fn Vec_WecPrint(p: *mut Vec_Wec_t, fSkipSingles: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Vec_WecPrintLits_imctk_abc_sys"] + pub fn Vec_WecPrintLits(p: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecCreateClasses_imctk_abc_sys"] + pub fn Vec_WecCreateClasses(vMap: *mut Vec_Int_t) -> *mut Vec_Wec_t; +} +extern "C" { + #[link_name = "Vec_WecCountNonTrivial_imctk_abc_sys"] + pub fn Vec_WecCountNonTrivial( + p: *mut Vec_Wec_t, + pnUsed: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecMaxLevelSize_imctk_abc_sys"] + pub fn Vec_WecMaxLevelSize(p: *mut Vec_Wec_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecCollectFirsts_imctk_abc_sys"] + pub fn Vec_WecCollectFirsts(p: *mut Vec_Wec_t) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Vec_WecConvertToVecPtr_imctk_abc_sys"] + pub fn Vec_WecConvertToVecPtr(p: *mut Vec_Wec_t) -> *mut Vec_Ptr_t; +} +extern "C" { + #[link_name = "Vec_WecIntHasMark_imctk_abc_sys"] + pub fn Vec_WecIntHasMark(vVec: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Vec_WecIntSetMark_imctk_abc_sys"] + pub fn Vec_WecIntSetMark(vVec: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_WecIntXorMark_imctk_abc_sys"] + pub fn Vec_WecIntXorMark(vVec: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_WecMarkLevels_imctk_abc_sys"] + pub fn Vec_WecMarkLevels(vCubes: *mut Vec_Wec_t, vLevels: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_WecUnmarkLevels_imctk_abc_sys"] + pub fn Vec_WecUnmarkLevels(vCubes: *mut Vec_Wec_t, vLevels: *mut Vec_Int_t); +} +extern "C" { + #[link_name = "Vec_WecRemoveEmpty_imctk_abc_sys"] + pub fn Vec_WecRemoveEmpty(vCubes: *mut Vec_Wec_t); +} +extern "C" { + #[link_name = "Vec_WecDumpBin_imctk_abc_sys"] + pub fn Vec_WecDumpBin( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Wec_t, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Vec_WecReadBin_imctk_abc_sys"] + pub fn Vec_WecReadBin( + pFileName: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Wec_t; +} +pub type Abc_Cex_t = Abc_Cex_t_; +#[repr(C)] +#[derive(Debug)] +pub struct Abc_Cex_t_ { + pub iPo: ::std::os::raw::c_int, + pub iFrame: ::std::os::raw::c_int, + pub nRegs: ::std::os::raw::c_int, + pub nPis: ::std::os::raw::c_int, + pub nBits: ::std::os::raw::c_int, + pub pData: __IncompleteArrayField<::std::os::raw::c_uint>, +} +#[test] +fn bindgen_test_layout_Abc_Cex_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(Abc_Cex_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Abc_Cex_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iPo) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(iPo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iFrame) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(iFrame) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRegs) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(nRegs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nPis) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(nPis) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(nBits) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pData) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Abc_Cex_t_), + "::", + stringify!(pData) + ) + ); +} +extern "C" { + pub fn Abc_CexAlloc( + nRegs: ::std::os::raw::c_int, + nTruePis: ::std::os::raw::c_int, + nFrames: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexAllocFull( + nRegs: ::std::os::raw::c_int, + nTruePis: ::std::os::raw::c_int, + nFrames: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexMakeTriv( + nRegs: ::std::os::raw::c_int, + nTruePis: ::std::os::raw::c_int, + nTruePos: ::std::os::raw::c_int, + iFrameOut: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexCreate( + nRegs: ::std::os::raw::c_int, + nTruePis: ::std::os::raw::c_int, + pArray: *mut ::std::os::raw::c_int, + iFrame: ::std::os::raw::c_int, + iPo: ::std::os::raw::c_int, + fSkipRegs: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexDup(p: *mut Abc_Cex_t, nRegsNew: ::std::os::raw::c_int) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexDeriveFromCombModel( + pModel: *mut ::std::os::raw::c_int, + nPis: ::std::os::raw::c_int, + nRegs: ::std::os::raw::c_int, + iPo: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexMerge( + pCex: *mut Abc_Cex_t, + pPart: *mut Abc_Cex_t, + iFrBeg: ::std::os::raw::c_int, + iFrEnd: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexPrintStats(p: *mut Abc_Cex_t); +} +extern "C" { + pub fn Abc_CexPrintStatsInputs(p: *mut Abc_Cex_t, nInputs: ::std::os::raw::c_int); +} +extern "C" { + pub fn Abc_CexPrint(p: *mut Abc_Cex_t); +} +extern "C" { + pub fn Abc_CexFreeP(p: *mut *mut Abc_Cex_t); +} +extern "C" { + pub fn Abc_CexFree(p: *mut Abc_Cex_t); +} +extern "C" { + pub fn Abc_CexTransformPhase( + p: *mut Abc_Cex_t, + nPisOld: ::std::os::raw::c_int, + nPosOld: ::std::os::raw::c_int, + nRegsOld: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexTransformTempor( + p: *mut Abc_Cex_t, + nPisOld: ::std::os::raw::c_int, + nPosOld: ::std::os::raw::c_int, + nRegsOld: ::std::os::raw::c_int, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexTransformUndc( + p: *mut Abc_Cex_t, + pInit: *mut ::std::os::raw::c_char, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexPermute(p: *mut Abc_Cex_t, vMapOld2New: *mut Vec_Int_t) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexPermuteTwo( + p: *mut Abc_Cex_t, + vPermOld: *mut Vec_Int_t, + vPermNew: *mut Vec_Int_t, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Abc_CexCountOnes(p: *mut Abc_Cex_t) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_MmFixed_t_ { + _unused: [u8; 0], +} +pub type Gia_MmFixed_t = Gia_MmFixed_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_MmFlex_t_ { + _unused: [u8; 0], +} +pub type Gia_MmFlex_t = Gia_MmFlex_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_MmStep_t_ { + _unused: [u8; 0], +} +pub type Gia_MmStep_t = Gia_MmStep_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Dat_t_ { + _unused: [u8; 0], +} +pub type Gia_Dat_t = Gia_Dat_t_; +pub type Gia_Rpr_t = Gia_Rpr_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Rpr_t_ { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_Gia_Rpr_t_() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Gia_Rpr_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Gia_Rpr_t_)) + ); +} +impl Gia_Rpr_t_ { + #[inline] + pub fn iRepr(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 28u8) as u32) } + } + #[inline] + pub fn set_iRepr(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 28u8, val as u64) + } + } + #[inline] + pub fn fProved(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_fProved(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn fFailed(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_fFailed(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn fColorA(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_fColorA(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn fColorB(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_fColorB(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + iRepr: ::std::os::raw::c_uint, + fProved: ::std::os::raw::c_uint, + fFailed: ::std::os::raw::c_uint, + fColorA: ::std::os::raw::c_uint, + fColorB: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 28u8, { + let iRepr: u32 = unsafe { ::std::mem::transmute(iRepr) }; + iRepr as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let fProved: u32 = unsafe { ::std::mem::transmute(fProved) }; + fProved as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let fFailed: u32 = unsafe { ::std::mem::transmute(fFailed) }; + fFailed as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let fColorA: u32 = unsafe { ::std::mem::transmute(fColorA) }; + fColorA as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let fColorB: u32 = unsafe { ::std::mem::transmute(fColorB) }; + fColorB as u64 + }); + __bindgen_bitfield_unit + } +} +pub type Gia_Plc_t = Gia_Plc_t_; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Plc_t_ { + pub _bitfield_align_1: [u16; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_Gia_Plc_t_() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Gia_Plc_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Gia_Plc_t_)) + ); +} +impl Gia_Plc_t_ { + #[inline] + pub fn fFixed(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_fFixed(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn xCoord(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 15u8) as u32) } + } + #[inline] + pub fn set_xCoord(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 15u8, val as u64) + } + } + #[inline] + pub fn fUndef(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_fUndef(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn yCoord(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 15u8) as u32) } + } + #[inline] + pub fn set_yCoord(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 15u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + fFixed: ::std::os::raw::c_uint, + xCoord: ::std::os::raw::c_uint, + fUndef: ::std::os::raw::c_uint, + yCoord: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let fFixed: u32 = unsafe { ::std::mem::transmute(fFixed) }; + fFixed as u64 + }); + __bindgen_bitfield_unit.set(1usize, 15u8, { + let xCoord: u32 = unsafe { ::std::mem::transmute(xCoord) }; + xCoord as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let fUndef: u32 = unsafe { ::std::mem::transmute(fUndef) }; + fUndef as u64 + }); + __bindgen_bitfield_unit.set(17usize, 15u8, { + let yCoord: u32 = unsafe { ::std::mem::transmute(yCoord) }; + yCoord as u64 + }); + __bindgen_bitfield_unit + } +} +pub type Gia_Obj_t = Gia_Obj_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Obj_t_ { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + pub Value: ::std::os::raw::c_uint, +} +#[test] +fn bindgen_test_layout_Gia_Obj_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Gia_Obj_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Gia_Obj_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Value) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gia_Obj_t_), + "::", + stringify!(Value) + ) + ); +} +impl Gia_Obj_t_ { + #[inline] + pub fn iDiff0(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 29u8) as u32) } + } + #[inline] + pub fn set_iDiff0(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 29u8, val as u64) + } + } + #[inline] + pub fn fCompl0(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_fCompl0(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn fMark0(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_fMark0(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn fTerm(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_fTerm(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub fn iDiff1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 29u8) as u32) } + } + #[inline] + pub fn set_iDiff1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 29u8, val as u64) + } + } + #[inline] + pub fn fCompl1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 1u8) as u32) } + } + #[inline] + pub fn set_fCompl1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(61usize, 1u8, val as u64) + } + } + #[inline] + pub fn fMark1(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(62usize, 1u8) as u32) } + } + #[inline] + pub fn set_fMark1(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(62usize, 1u8, val as u64) + } + } + #[inline] + pub fn fPhase(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u32) } + } + #[inline] + pub fn set_fPhase(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(63usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + iDiff0: ::std::os::raw::c_uint, + fCompl0: ::std::os::raw::c_uint, + fMark0: ::std::os::raw::c_uint, + fTerm: ::std::os::raw::c_uint, + iDiff1: ::std::os::raw::c_uint, + fCompl1: ::std::os::raw::c_uint, + fMark1: ::std::os::raw::c_uint, + fPhase: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 8usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 29u8, { + let iDiff0: u32 = unsafe { ::std::mem::transmute(iDiff0) }; + iDiff0 as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let fCompl0: u32 = unsafe { ::std::mem::transmute(fCompl0) }; + fCompl0 as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let fMark0: u32 = unsafe { ::std::mem::transmute(fMark0) }; + fMark0 as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let fTerm: u32 = unsafe { ::std::mem::transmute(fTerm) }; + fTerm as u64 + }); + __bindgen_bitfield_unit.set(32usize, 29u8, { + let iDiff1: u32 = unsafe { ::std::mem::transmute(iDiff1) }; + iDiff1 as u64 + }); + __bindgen_bitfield_unit.set(61usize, 1u8, { + let fCompl1: u32 = unsafe { ::std::mem::transmute(fCompl1) }; + fCompl1 as u64 + }); + __bindgen_bitfield_unit.set(62usize, 1u8, { + let fMark1: u32 = unsafe { ::std::mem::transmute(fMark1) }; + fMark1 as u64 + }); + __bindgen_bitfield_unit.set(63usize, 1u8, { + let fPhase: u32 = unsafe { ::std::mem::transmute(fPhase) }; + fPhase as u64 + }); + __bindgen_bitfield_unit + } +} +pub type Gia_Man_t = Gia_Man_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Man_t_ { + pub pName: *mut ::std::os::raw::c_char, + pub pSpec: *mut ::std::os::raw::c_char, + pub nRegs: ::std::os::raw::c_int, + pub nRegsAlloc: ::std::os::raw::c_int, + pub nObjs: ::std::os::raw::c_int, + pub nObjsAlloc: ::std::os::raw::c_int, + pub pObjs: *mut Gia_Obj_t, + pub pMuxes: *mut ::std::os::raw::c_uint, + pub nXors: ::std::os::raw::c_int, + pub nMuxes: ::std::os::raw::c_int, + pub nBufs: ::std::os::raw::c_int, + pub vCis: *mut Vec_Int_t, + pub vCos: *mut Vec_Int_t, + pub vHash: Vec_Int_t, + pub vHTable: Vec_Int_t, + pub fAddStrash: ::std::os::raw::c_int, + pub fSweeper: ::std::os::raw::c_int, + pub fGiaSimple: ::std::os::raw::c_int, + pub vRefs: Vec_Int_t, + pub pRefs: *mut ::std::os::raw::c_int, + pub pLutRefs: *mut ::std::os::raw::c_int, + pub vLevels: *mut Vec_Int_t, + pub nLevels: ::std::os::raw::c_int, + pub nConstrs: ::std::os::raw::c_int, + pub nTravIds: ::std::os::raw::c_int, + pub nFront: ::std::os::raw::c_int, + pub pReprsOld: *mut ::std::os::raw::c_int, + pub pReprs: *mut Gia_Rpr_t, + pub pNexts: *mut ::std::os::raw::c_int, + pub pSibls: *mut ::std::os::raw::c_int, + pub pIso: *mut ::std::os::raw::c_int, + pub nTerLoop: ::std::os::raw::c_int, + pub nTerStates: ::std::os::raw::c_int, + pub pFanData: *mut ::std::os::raw::c_int, + pub nFansAlloc: ::std::os::raw::c_int, + pub vFanoutNums: *mut Vec_Int_t, + pub vFanout: *mut Vec_Int_t, + pub vMapping: *mut Vec_Int_t, + pub vMapping2: *mut Vec_Wec_t, + pub vFanouts2: *mut Vec_Wec_t, + pub vCellMapping: *mut Vec_Int_t, + pub pSatlutWinman: *mut ::std::os::raw::c_void, + pub vPacking: *mut Vec_Int_t, + pub vConfigs: *mut Vec_Int_t, + pub pCellStr: *mut ::std::os::raw::c_char, + pub vLutConfigs: *mut Vec_Int_t, + pub vEdgeDelay: *mut Vec_Int_t, + pub vEdgeDelayR: *mut Vec_Int_t, + pub vEdge1: *mut Vec_Int_t, + pub vEdge2: *mut Vec_Int_t, + pub pCexComb: *mut Abc_Cex_t, + pub pCexSeq: *mut Abc_Cex_t, + pub vSeqModelVec: *mut Vec_Ptr_t, + pub vCopies: Vec_Int_t, + pub vCopies2: Vec_Int_t, + pub vVar2Obj: *mut Vec_Int_t, + pub vTruths: *mut Vec_Int_t, + pub vFlopClasses: *mut Vec_Int_t, + pub vGateClasses: *mut Vec_Int_t, + pub vObjClasses: *mut Vec_Int_t, + pub vInitClasses: *mut Vec_Int_t, + pub vRegClasses: *mut Vec_Int_t, + pub vRegInits: *mut Vec_Int_t, + pub vDoms: *mut Vec_Int_t, + pub vBarBufs: *mut Vec_Int_t, + pub vXors: *mut Vec_Int_t, + pub pSwitching: *mut ::std::os::raw::c_uchar, + pub pPlacement: *mut Gia_Plc_t, + pub pAigExtra: *mut Gia_Man_t, + pub vInArrs: *mut Vec_Flt_t, + pub vOutReqs: *mut Vec_Flt_t, + pub vCiArrs: *mut Vec_Int_t, + pub vCoReqs: *mut Vec_Int_t, + pub vCoArrs: *mut Vec_Int_t, + pub vCoAttrs: *mut Vec_Int_t, + pub vWeights: *mut Vec_Int_t, + pub And2Delay: ::std::os::raw::c_int, + pub DefInArrs: f32, + pub DefOutReqs: f32, + pub vSwitching: *mut Vec_Int_t, + pub pTravIds: *mut ::std::os::raw::c_int, + pub nTravIdsAlloc: ::std::os::raw::c_int, + pub vNamesIn: *mut Vec_Ptr_t, + pub vNamesOut: *mut Vec_Ptr_t, + pub vNamesNode: *mut Vec_Ptr_t, + pub vUserPiIds: *mut Vec_Int_t, + pub vUserPoIds: *mut Vec_Int_t, + pub vUserFfIds: *mut Vec_Int_t, + pub vCiNumsOrig: *mut Vec_Int_t, + pub vCoNumsOrig: *mut Vec_Int_t, + pub vIdsOrig: *mut Vec_Int_t, + pub vIdsEquiv: *mut Vec_Int_t, + pub vCofVars: *mut Vec_Int_t, + pub vClockDoms: *mut Vec_Vec_t, + pub vTiming: *mut Vec_Flt_t, + pub pManTime: *mut ::std::os::raw::c_void, + pub pLutLib: *mut ::std::os::raw::c_void, + pub nHashHit: word, + pub nHashMiss: word, + pub pData: *mut ::std::os::raw::c_void, + pub pData2: *mut ::std::os::raw::c_uint, + pub iData: ::std::os::raw::c_int, + pub iData2: ::std::os::raw::c_int, + pub nAnd2Delay: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub MappedArea: ::std::os::raw::c_int, + pub MappedDelay: ::std::os::raw::c_int, + pub fBuiltInSim: ::std::os::raw::c_int, + pub iPatsPi: ::std::os::raw::c_int, + pub nSimWords: ::std::os::raw::c_int, + pub nSimWordsT: ::std::os::raw::c_int, + pub iPastPiMax: ::std::os::raw::c_int, + pub nSimWordsMax: ::std::os::raw::c_int, + pub vSims: *mut Vec_Wrd_t, + pub vSimsT: *mut Vec_Wrd_t, + pub vSimsPi: *mut Vec_Wrd_t, + pub vSimsPo: *mut Vec_Wrd_t, + pub vClassOld: *mut Vec_Int_t, + pub vClassNew: *mut Vec_Int_t, + pub vPats: *mut Vec_Int_t, + pub vPolars: *mut Vec_Bit_t, + pub fIncrSim: ::std::os::raw::c_int, + pub iNextPi: ::std::os::raw::c_int, + pub iTimeStamp: ::std::os::raw::c_int, + pub vTimeStamps: *mut Vec_Int_t, + pub nTtVars: ::std::os::raw::c_int, + pub nTtWords: ::std::os::raw::c_int, + pub vTtNums: *mut Vec_Int_t, + pub vTtNodes: *mut Vec_Int_t, + pub vTtInputs: *mut Vec_Ptr_t, + pub vTtMemory: *mut Vec_Wrd_t, + pub vSuper: *mut Vec_Int_t, + pub vStore: *mut Vec_Int_t, + pub iSuppPi: ::std::os::raw::c_int, + pub nSuppWords: ::std::os::raw::c_int, + pub vSuppWords: *mut Vec_Wrd_t, + pub vCopiesTwo: Vec_Int_t, + pub vSuppVars: Vec_Int_t, + pub vVarMap: Vec_Int_t, + pub pUData: *mut Gia_Dat_t, + pub vStopsF: *mut Vec_Str_t, + pub vStopsB: *mut Vec_Str_t, +} +#[test] +fn bindgen_test_layout_Gia_Man_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 1064usize, + concat!("Size of: ", stringify!(Gia_Man_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Gia_Man_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pName) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pName) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSpec) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pSpec) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRegs) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nRegs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRegsAlloc) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nRegsAlloc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nObjs) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nObjs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nObjsAlloc) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nObjsAlloc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pObjs) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pObjs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pMuxes) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pMuxes) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nXors) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nXors) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nMuxes) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nMuxes) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBufs) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nBufs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCis) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCis) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCos) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCos) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vHash) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vHash) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vHTable) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vHTable) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fAddStrash) as usize - ptr as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fAddStrash) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSweeper) as usize - ptr as usize }, + 116usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fSweeper) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fGiaSimple) as usize - ptr as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fGiaSimple) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vRefs) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vRefs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefs) as usize - ptr as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pRefs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLutRefs) as usize - ptr as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pLutRefs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vLevels) as usize - ptr as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vLevels) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLevels) as usize - ptr as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nLevels) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nConstrs) as usize - ptr as usize }, + 172usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nConstrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTravIds) as usize - ptr as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTravIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFront) as usize - ptr as usize }, + 180usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nFront) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pReprsOld) as usize - ptr as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pReprsOld) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pReprs) as usize - ptr as usize }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pReprs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pNexts) as usize - ptr as usize }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pNexts) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSibls) as usize - ptr as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pSibls) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pIso) as usize - ptr as usize }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pIso) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTerLoop) as usize - ptr as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTerLoop) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTerStates) as usize - ptr as usize }, + 228usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTerStates) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pFanData) as usize - ptr as usize }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pFanData) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFansAlloc) as usize - ptr as usize }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nFansAlloc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vFanoutNums) as usize - ptr as usize }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vFanoutNums) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vFanout) as usize - ptr as usize }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vFanout) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vMapping) as usize - ptr as usize }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vMapping) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vMapping2) as usize - ptr as usize }, + 272usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vMapping2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vFanouts2) as usize - ptr as usize }, + 280usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vFanouts2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCellMapping) as usize - ptr as usize }, + 288usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCellMapping) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSatlutWinman) as usize - ptr as usize }, + 296usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pSatlutWinman) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vPacking) as usize - ptr as usize }, + 304usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vPacking) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vConfigs) as usize - ptr as usize }, + 312usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vConfigs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pCellStr) as usize - ptr as usize }, + 320usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pCellStr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vLutConfigs) as usize - ptr as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vLutConfigs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vEdgeDelay) as usize - ptr as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vEdgeDelay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vEdgeDelayR) as usize - ptr as usize }, + 344usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vEdgeDelayR) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vEdge1) as usize - ptr as usize }, + 352usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vEdge1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vEdge2) as usize - ptr as usize }, + 360usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vEdge2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pCexComb) as usize - ptr as usize }, + 368usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pCexComb) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pCexSeq) as usize - ptr as usize }, + 376usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pCexSeq) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSeqModelVec) as usize - ptr as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSeqModelVec) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCopies) as usize - ptr as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCopies) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCopies2) as usize - ptr as usize }, + 408usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCopies2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vVar2Obj) as usize - ptr as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vVar2Obj) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTruths) as usize - ptr as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTruths) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vFlopClasses) as usize - ptr as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vFlopClasses) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vGateClasses) as usize - ptr as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vGateClasses) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vObjClasses) as usize - ptr as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vObjClasses) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vInitClasses) as usize - ptr as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vInitClasses) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vRegClasses) as usize - ptr as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vRegClasses) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vRegInits) as usize - ptr as usize }, + 480usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vRegInits) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vDoms) as usize - ptr as usize }, + 488usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vDoms) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vBarBufs) as usize - ptr as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vBarBufs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vXors) as usize - ptr as usize }, + 504usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vXors) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSwitching) as usize - ptr as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pSwitching) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPlacement) as usize - ptr as usize }, + 520usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pPlacement) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pAigExtra) as usize - ptr as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pAigExtra) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vInArrs) as usize - ptr as usize }, + 536usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vInArrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vOutReqs) as usize - ptr as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vOutReqs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCiArrs) as usize - ptr as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCiArrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCoReqs) as usize - ptr as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCoReqs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCoArrs) as usize - ptr as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCoArrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCoAttrs) as usize - ptr as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCoAttrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vWeights) as usize - ptr as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vWeights) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).And2Delay) as usize - ptr as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(And2Delay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).DefInArrs) as usize - ptr as usize }, + 596usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(DefInArrs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).DefOutReqs) as usize - ptr as usize }, + 600usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(DefOutReqs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSwitching) as usize - ptr as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSwitching) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pTravIds) as usize - ptr as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pTravIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTravIdsAlloc) as usize - ptr as usize }, + 624usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTravIdsAlloc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vNamesIn) as usize - ptr as usize }, + 632usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vNamesIn) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vNamesOut) as usize - ptr as usize }, + 640usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vNamesOut) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vNamesNode) as usize - ptr as usize }, + 648usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vNamesNode) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vUserPiIds) as usize - ptr as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vUserPiIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vUserPoIds) as usize - ptr as usize }, + 664usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vUserPoIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vUserFfIds) as usize - ptr as usize }, + 672usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vUserFfIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCiNumsOrig) as usize - ptr as usize }, + 680usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCiNumsOrig) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCoNumsOrig) as usize - ptr as usize }, + 688usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCoNumsOrig) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vIdsOrig) as usize - ptr as usize }, + 696usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vIdsOrig) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vIdsEquiv) as usize - ptr as usize }, + 704usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vIdsEquiv) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCofVars) as usize - ptr as usize }, + 712usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCofVars) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vClockDoms) as usize - ptr as usize }, + 720usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vClockDoms) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTiming) as usize - ptr as usize }, + 728usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTiming) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pManTime) as usize - ptr as usize }, + 736usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pManTime) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLutLib) as usize - ptr as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pLutLib) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nHashHit) as usize - ptr as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nHashHit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nHashMiss) as usize - ptr as usize }, + 760usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nHashMiss) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pData) as usize - ptr as usize }, + 768usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pData) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pData2) as usize - ptr as usize }, + 776usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pData2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iData) as usize - ptr as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iData) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iData2) as usize - ptr as usize }, + 788usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iData2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nAnd2Delay) as usize - ptr as usize }, + 792usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nAnd2Delay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 796usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MappedArea) as usize - ptr as usize }, + 800usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(MappedArea) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MappedDelay) as usize - ptr as usize }, + 804usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(MappedDelay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fBuiltInSim) as usize - ptr as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fBuiltInSim) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iPatsPi) as usize - ptr as usize }, + 812usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iPatsPi) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSimWords) as usize - ptr as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nSimWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSimWordsT) as usize - ptr as usize }, + 820usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nSimWordsT) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iPastPiMax) as usize - ptr as usize }, + 824usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iPastPiMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSimWordsMax) as usize - ptr as usize }, + 828usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nSimWordsMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSims) as usize - ptr as usize }, + 832usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSims) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSimsT) as usize - ptr as usize }, + 840usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSimsT) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSimsPi) as usize - ptr as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSimsPi) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSimsPo) as usize - ptr as usize }, + 856usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSimsPo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vClassOld) as usize - ptr as usize }, + 864usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vClassOld) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vClassNew) as usize - ptr as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vClassNew) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vPats) as usize - ptr as usize }, + 880usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vPats) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vPolars) as usize - ptr as usize }, + 888usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vPolars) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fIncrSim) as usize - ptr as usize }, + 896usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(fIncrSim) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iNextPi) as usize - ptr as usize }, + 900usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iNextPi) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iTimeStamp) as usize - ptr as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iTimeStamp) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTimeStamps) as usize - ptr as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTimeStamps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTtVars) as usize - ptr as usize }, + 920usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTtVars) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nTtWords) as usize - ptr as usize }, + 924usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nTtWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTtNums) as usize - ptr as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTtNums) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTtNodes) as usize - ptr as usize }, + 936usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTtNodes) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTtInputs) as usize - ptr as usize }, + 944usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTtInputs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vTtMemory) as usize - ptr as usize }, + 952usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vTtMemory) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSuper) as usize - ptr as usize }, + 960usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSuper) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vStore) as usize - ptr as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vStore) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iSuppPi) as usize - ptr as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(iSuppPi) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSuppWords) as usize - ptr as usize }, + 980usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(nSuppWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSuppWords) as usize - ptr as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSuppWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCopiesTwo) as usize - ptr as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vCopiesTwo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vSuppVars) as usize - ptr as usize }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vSuppVars) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vVarMap) as usize - ptr as usize }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vVarMap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pUData) as usize - ptr as usize }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(pUData) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vStopsF) as usize - ptr as usize }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vStopsF) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vStopsB) as usize - ptr as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(Gia_Man_t_), + "::", + stringify!(vStopsB) + ) + ); +} +pub type Gps_Par_t = Gps_Par_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gps_Par_t_ { + pub fTents: ::std::os::raw::c_int, + pub fSwitch: ::std::os::raw::c_int, + pub fCut: ::std::os::raw::c_int, + pub fNpn: ::std::os::raw::c_int, + pub fLutProf: ::std::os::raw::c_int, + pub fMuxXor: ::std::os::raw::c_int, + pub fMiter: ::std::os::raw::c_int, + pub fSkipMap: ::std::os::raw::c_int, + pub fSlacks: ::std::os::raw::c_int, + pub fNoColor: ::std::os::raw::c_int, + pub pDumpFile: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_Gps_Par_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Gps_Par_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Gps_Par_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fTents) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fTents) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSwitch) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fSwitch) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCut) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fCut) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fNpn) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fNpn) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fLutProf) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fLutProf) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fMuxXor) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fMuxXor) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fMiter) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSkipMap) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fSkipMap) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSlacks) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fSlacks) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fNoColor) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(fNoColor) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDumpFile) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Gps_Par_t_), + "::", + stringify!(pDumpFile) + ) + ); +} +pub type Emb_Par_t = Emb_Par_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Emb_Par_t_ { + pub nDims: ::std::os::raw::c_int, + pub nSols: ::std::os::raw::c_int, + pub nIters: ::std::os::raw::c_int, + pub fRefine: ::std::os::raw::c_int, + pub fCluster: ::std::os::raw::c_int, + pub fDump: ::std::os::raw::c_int, + pub fDumpLarge: ::std::os::raw::c_int, + pub fShowImage: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Emb_Par_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 36usize, + concat!("Size of: ", stringify!(Emb_Par_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Emb_Par_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nDims) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(nDims) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSols) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(nSols) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nIters) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(nIters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fRefine) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fRefine) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCluster) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fCluster) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDump) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fDump) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDumpLarge) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fDumpLarge) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fShowImage) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fShowImage) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Emb_Par_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Gia_ParFra_t = Gia_ParFra_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_ParFra_t_ { + pub nFrames: ::std::os::raw::c_int, + pub fInit: ::std::os::raw::c_int, + pub fSaveLastLit: ::std::os::raw::c_int, + pub fDisableSt: ::std::os::raw::c_int, + pub fOrPos: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Gia_ParFra_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Gia_ParFra_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Gia_ParFra_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFrames) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(nFrames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fInit) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(fInit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSaveLastLit) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(fSaveLastLit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDisableSt) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(fDisableSt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fOrPos) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(fOrPos) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParFra_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Gia_ParSim_t = Gia_ParSim_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_ParSim_t_ { + pub nWords: ::std::os::raw::c_int, + pub nIters: ::std::os::raw::c_int, + pub RandSeed: ::std::os::raw::c_int, + pub TimeLimit: ::std::os::raw::c_int, + pub fCheckMiter: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub iOutFail: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Gia_ParSim_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 28usize, + concat!("Size of: ", stringify!(Gia_ParSim_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Gia_ParSim_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nIters) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(nIters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RandSeed) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(RandSeed) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(TimeLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCheckMiter) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(fCheckMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iOutFail) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Gia_ParSim_t_), + "::", + stringify!(iOutFail) + ) + ); +} +pub type Gia_ManSim_t = Gia_ManSim_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_ManSim_t_ { + pub pAig: *mut Gia_Man_t, + pub pPars: *mut Gia_ParSim_t, + pub nWords: ::std::os::raw::c_int, + pub vCis2Ids: *mut Vec_Int_t, + pub vConsts: *mut Vec_Int_t, + pub pDataSim: *mut ::std::os::raw::c_uint, + pub pDataSimCis: *mut ::std::os::raw::c_uint, + pub pDataSimCos: *mut ::std::os::raw::c_uint, +} +#[test] +fn bindgen_test_layout_Gia_ManSim_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Gia_ManSim_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Gia_ManSim_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pAig) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(pAig) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPars) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(pPars) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vCis2Ids) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(vCis2Ids) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vConsts) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(vConsts) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDataSim) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(pDataSim) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDataSimCis) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(pDataSimCis) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDataSimCos) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Gia_ManSim_t_), + "::", + stringify!(pDataSimCos) + ) + ); +} +pub type Jf_Par_t = Jf_Par_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Jf_Par_t_ { + pub nLutSize: ::std::os::raw::c_int, + pub nCutNum: ::std::os::raw::c_int, + pub nProcNum: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nRoundsEla: ::std::os::raw::c_int, + pub nRelaxRatio: ::std::os::raw::c_int, + pub nCoarseLimit: ::std::os::raw::c_int, + pub nAreaTuner: ::std::os::raw::c_int, + pub nReqTimeFlex: ::std::os::raw::c_int, + pub nVerbLimit: ::std::os::raw::c_int, + pub nDelayLut1: ::std::os::raw::c_int, + pub nDelayLut2: ::std::os::raw::c_int, + pub nFastEdges: ::std::os::raw::c_int, + pub DelayTarget: ::std::os::raw::c_int, + pub fAreaOnly: ::std::os::raw::c_int, + pub fPinPerm: ::std::os::raw::c_int, + pub fPinQuick: ::std::os::raw::c_int, + pub fPinFilter: ::std::os::raw::c_int, + pub fOptEdge: ::std::os::raw::c_int, + pub fUseMux7: ::std::os::raw::c_int, + pub fPower: ::std::os::raw::c_int, + pub fCoarsen: ::std::os::raw::c_int, + pub fCutMin: ::std::os::raw::c_int, + pub fFuncDsd: ::std::os::raw::c_int, + pub fGenCnf: ::std::os::raw::c_int, + pub fGenLit: ::std::os::raw::c_int, + pub fCnfObjIds: ::std::os::raw::c_int, + pub fAddOrCla: ::std::os::raw::c_int, + pub fCnfMapping: ::std::os::raw::c_int, + pub fPureAig: ::std::os::raw::c_int, + pub fDoAverage: ::std::os::raw::c_int, + pub fCutHashing: ::std::os::raw::c_int, + pub fCutSimple: ::std::os::raw::c_int, + pub fCutGroup: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub nLutSizeMax: ::std::os::raw::c_int, + pub nCutNumMax: ::std::os::raw::c_int, + pub nProcNumMax: ::std::os::raw::c_int, + pub nLutSizeMux: ::std::os::raw::c_int, + pub Delay: word, + pub Area: word, + pub Edge: word, + pub Clause: word, + pub Mux7: word, + pub WordMapDelay: word, + pub WordMapArea: word, + pub WordMapDelayTarget: word, + pub MapDelay: ::std::os::raw::c_int, + pub MapArea: f32, + pub MapAreaF: f32, + pub MapDelayTarget: f32, + pub Epsilon: f32, + pub pTimesArr: *mut f32, + pub pTimesReq: *mut f32, +} +#[test] +fn bindgen_test_layout_Jf_Par_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 264usize, + concat!("Size of: ", stringify!(Jf_Par_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Jf_Par_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLutSize) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nLutSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCutNum) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nCutNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nProcNum) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nProcNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRoundsEla) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nRoundsEla) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRelaxRatio) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nRelaxRatio) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCoarseLimit) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nCoarseLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nAreaTuner) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nAreaTuner) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nReqTimeFlex) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nReqTimeFlex) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nVerbLimit) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nVerbLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nDelayLut1) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nDelayLut1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nDelayLut2) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nDelayLut2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFastEdges) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nFastEdges) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).DelayTarget) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(DelayTarget) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fAreaOnly) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fAreaOnly) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPinPerm) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fPinPerm) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPinQuick) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fPinQuick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPinFilter) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fPinFilter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fOptEdge) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fOptEdge) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseMux7) as usize - ptr as usize }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fUseMux7) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPower) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fPower) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCoarsen) as usize - ptr as usize }, + 84usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCoarsen) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCutMin) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCutMin) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fFuncDsd) as usize - ptr as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fFuncDsd) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fGenCnf) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fGenCnf) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fGenLit) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fGenLit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCnfObjIds) as usize - ptr as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCnfObjIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fAddOrCla) as usize - ptr as usize }, + 108usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fAddOrCla) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCnfMapping) as usize - ptr as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCnfMapping) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPureAig) as usize - ptr as usize }, + 116usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fPureAig) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDoAverage) as usize - ptr as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fDoAverage) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCutHashing) as usize - ptr as usize }, + 124usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCutHashing) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCutSimple) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCutSimple) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCutGroup) as usize - ptr as usize }, + 132usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fCutGroup) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 140usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLutSizeMax) as usize - ptr as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nLutSizeMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCutNumMax) as usize - ptr as usize }, + 148usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nCutNumMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nProcNumMax) as usize - ptr as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nProcNumMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLutSizeMux) as usize - ptr as usize }, + 156usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(nLutSizeMux) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Delay) as usize - ptr as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Delay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Area) as usize - ptr as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Area) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Edge) as usize - ptr as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Edge) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Clause) as usize - ptr as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Clause) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Mux7) as usize - ptr as usize }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Mux7) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).WordMapDelay) as usize - ptr as usize }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(WordMapDelay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).WordMapArea) as usize - ptr as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(WordMapArea) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).WordMapDelayTarget) as usize - ptr as usize }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(WordMapDelayTarget) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MapDelay) as usize - ptr as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(MapDelay) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MapArea) as usize - ptr as usize }, + 228usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(MapArea) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MapAreaF) as usize - ptr as usize }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(MapAreaF) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MapDelayTarget) as usize - ptr as usize }, + 236usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(MapDelayTarget) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).Epsilon) as usize - ptr as usize }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(Epsilon) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pTimesArr) as usize - ptr as usize }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(pTimesArr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pTimesReq) as usize - ptr as usize }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Jf_Par_t_), + "::", + stringify!(pTimesReq) + ) + ); +} +extern "C" { + #[link_name = "Gia_ObjCutSign_imctk_abc_sys"] + pub fn Gia_ObjCutSign(ObjId: ::std::os::raw::c_uint) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Gia_WordHasOneBit_imctk_abc_sys"] + pub fn Gia_WordHasOneBit(uWord: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_WordHasOnePair_imctk_abc_sys"] + pub fn Gia_WordHasOnePair(uWord: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_WordCountOnes_imctk_abc_sys"] + pub fn Gia_WordCountOnes(uWord: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_WordFindFirstBit_imctk_abc_sys"] + pub fn Gia_WordFindFirstBit(uWord: ::std::os::raw::c_uint) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManTruthIsConst0_imctk_abc_sys"] + pub fn Gia_ManTruthIsConst0( + pIn: *mut ::std::os::raw::c_uint, + nVars: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManTruthIsConst1_imctk_abc_sys"] + pub fn Gia_ManTruthIsConst1( + pIn: *mut ::std::os::raw::c_uint, + nVars: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManTruthCopy_imctk_abc_sys"] + pub fn Gia_ManTruthCopy( + pOut: *mut ::std::os::raw::c_uint, + pIn: *mut ::std::os::raw::c_uint, + nVars: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ManTruthClear_imctk_abc_sys"] + pub fn Gia_ManTruthClear(pOut: *mut ::std::os::raw::c_uint, nVars: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ManTruthFill_imctk_abc_sys"] + pub fn Gia_ManTruthFill(pOut: *mut ::std::os::raw::c_uint, nVars: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ManTruthNot_imctk_abc_sys"] + pub fn Gia_ManTruthNot( + pOut: *mut ::std::os::raw::c_uint, + pIn: *mut ::std::os::raw::c_uint, + nVars: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ManConst0Lit_imctk_abc_sys"] + pub fn Gia_ManConst0Lit() -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManConst1Lit_imctk_abc_sys"] + pub fn Gia_ManConst1Lit() -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManIsConst0Lit_imctk_abc_sys"] + pub fn Gia_ManIsConst0Lit(iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManIsConst1Lit_imctk_abc_sys"] + pub fn Gia_ManIsConst1Lit(iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManIsConstLit_imctk_abc_sys"] + pub fn Gia_ManIsConstLit(iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_Regular_imctk_abc_sys"] + pub fn Gia_Regular(p: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_Not_imctk_abc_sys"] + pub fn Gia_Not(p: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_NotCond_imctk_abc_sys"] + pub fn Gia_NotCond(p: *mut Gia_Obj_t, c: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_IsComplement_imctk_abc_sys"] + pub fn Gia_IsComplement(p: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManName_imctk_abc_sys"] + pub fn Gia_ManName(p: *mut Gia_Man_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Gia_ManCiNum_imctk_abc_sys"] + pub fn Gia_ManCiNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManCoNum_imctk_abc_sys"] + pub fn Gia_ManCoNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPiNum_imctk_abc_sys"] + pub fn Gia_ManPiNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPoNum_imctk_abc_sys"] + pub fn Gia_ManPoNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManRegNum_imctk_abc_sys"] + pub fn Gia_ManRegNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManObjNum_imctk_abc_sys"] + pub fn Gia_ManObjNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAndNum_imctk_abc_sys"] + pub fn Gia_ManAndNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManXorNum_imctk_abc_sys"] + pub fn Gia_ManXorNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManMuxNum_imctk_abc_sys"] + pub fn Gia_ManMuxNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManBufNum_imctk_abc_sys"] + pub fn Gia_ManBufNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAndNotBufNum_imctk_abc_sys"] + pub fn Gia_ManAndNotBufNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManCandNum_imctk_abc_sys"] + pub fn Gia_ManCandNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManConstrNum_imctk_abc_sys"] + pub fn Gia_ManConstrNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManFlipVerbose_imctk_abc_sys"] + pub fn Gia_ManFlipVerbose(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ManHasChoices_imctk_abc_sys"] + pub fn Gia_ManHasChoices(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManChoiceNum_imctk_abc_sys"] + pub fn Gia_ManChoiceNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManConst0_imctk_abc_sys"] + pub fn Gia_ManConst0(p: *mut Gia_Man_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManConst1_imctk_abc_sys"] + pub fn Gia_ManConst1(p: *mut Gia_Man_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManObj_imctk_abc_sys"] + pub fn Gia_ManObj(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManCi_imctk_abc_sys"] + pub fn Gia_ManCi(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManCo_imctk_abc_sys"] + pub fn Gia_ManCo(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManPi_imctk_abc_sys"] + pub fn Gia_ManPi(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManPo_imctk_abc_sys"] + pub fn Gia_ManPo(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManRo_imctk_abc_sys"] + pub fn Gia_ManRo(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManRi_imctk_abc_sys"] + pub fn Gia_ManRi(p: *mut Gia_Man_t, v: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjId_imctk_abc_sys"] + pub fn Gia_ObjId(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCioId_imctk_abc_sys"] + pub fn Gia_ObjCioId(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetCioId_imctk_abc_sys"] + pub fn Gia_ObjSetCioId(pObj: *mut Gia_Obj_t, v: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjValue_imctk_abc_sys"] + pub fn Gia_ObjValue(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetValue_imctk_abc_sys"] + pub fn Gia_ObjSetValue(pObj: *mut Gia_Obj_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjPhase_imctk_abc_sys"] + pub fn Gia_ObjPhase(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjPhaseReal_imctk_abc_sys"] + pub fn Gia_ObjPhaseReal(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjPhaseDiff_imctk_abc_sys"] + pub fn Gia_ObjPhaseDiff( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCiName_imctk_abc_sys"] + pub fn Gia_ObjCiName( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Gia_ObjCoName_imctk_abc_sys"] + pub fn Gia_ObjCoName( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Gia_ObjName_imctk_abc_sys"] + pub fn Gia_ObjName(p: *mut Gia_Man_t, i: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Gia_ObjNameObj_imctk_abc_sys"] + pub fn Gia_ObjNameObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "Gia_ObjIsTerm_imctk_abc_sys"] + pub fn Gia_ObjIsTerm(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsAndOrConst0_imctk_abc_sys"] + pub fn Gia_ObjIsAndOrConst0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCi_imctk_abc_sys"] + pub fn Gia_ObjIsCi(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCo_imctk_abc_sys"] + pub fn Gia_ObjIsCo(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsAnd_imctk_abc_sys"] + pub fn Gia_ObjIsAnd(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsXor_imctk_abc_sys"] + pub fn Gia_ObjIsXor(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsMuxId_imctk_abc_sys"] + pub fn Gia_ObjIsMuxId(p: *mut Gia_Man_t, iObj: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsMux_imctk_abc_sys"] + pub fn Gia_ObjIsMux(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsAndReal_imctk_abc_sys"] + pub fn Gia_ObjIsAndReal(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsBuf_imctk_abc_sys"] + pub fn Gia_ObjIsBuf(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsAndNotBuf_imctk_abc_sys"] + pub fn Gia_ObjIsAndNotBuf(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCand_imctk_abc_sys"] + pub fn Gia_ObjIsCand(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsConst0_imctk_abc_sys"] + pub fn Gia_ObjIsConst0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManObjIsConst0_imctk_abc_sys"] + pub fn Gia_ManObjIsConst0(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_Obj2Lit_imctk_abc_sys"] + pub fn Gia_Obj2Lit(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_Lit2Obj_imctk_abc_sys"] + pub fn Gia_Lit2Obj(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManCiLit_imctk_abc_sys"] + pub fn Gia_ManCiLit(p: *mut Gia_Man_t, CiId: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManIdToCioId_imctk_abc_sys"] + pub fn Gia_ManIdToCioId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManCiIdToId_imctk_abc_sys"] + pub fn Gia_ManCiIdToId(p: *mut Gia_Man_t, CiId: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManCoIdToId_imctk_abc_sys"] + pub fn Gia_ManCoIdToId(p: *mut Gia_Man_t, CoId: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsPi_imctk_abc_sys"] + pub fn Gia_ObjIsPi(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsPo_imctk_abc_sys"] + pub fn Gia_ObjIsPo(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsRo_imctk_abc_sys"] + pub fn Gia_ObjIsRo(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsRi_imctk_abc_sys"] + pub fn Gia_ObjIsRi(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRoToRi_imctk_abc_sys"] + pub fn Gia_ObjRoToRi(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjRiToRo_imctk_abc_sys"] + pub fn Gia_ObjRiToRo(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjRoToRiId_imctk_abc_sys"] + pub fn Gia_ObjRoToRiId( + p: *mut Gia_Man_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRiToRoId_imctk_abc_sys"] + pub fn Gia_ObjRiToRoId( + p: *mut Gia_Man_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjDiff0_imctk_abc_sys"] + pub fn Gia_ObjDiff0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjDiff1_imctk_abc_sys"] + pub fn Gia_ObjDiff1(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninC0_imctk_abc_sys"] + pub fn Gia_ObjFaninC0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninC1_imctk_abc_sys"] + pub fn Gia_ObjFaninC1(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninC2_imctk_abc_sys"] + pub fn Gia_ObjFaninC2(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninC_imctk_abc_sys"] + pub fn Gia_ObjFaninC(pObj: *mut Gia_Obj_t, n: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin0_imctk_abc_sys"] + pub fn Gia_ObjFanin0(pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjFanin1_imctk_abc_sys"] + pub fn Gia_ObjFanin1(pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjFanin2_imctk_abc_sys"] + pub fn Gia_ObjFanin2(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjFanin_imctk_abc_sys"] + pub fn Gia_ObjFanin(pObj: *mut Gia_Obj_t, n: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjChild0_imctk_abc_sys"] + pub fn Gia_ObjChild0(pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjChild1_imctk_abc_sys"] + pub fn Gia_ObjChild1(pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjChild2_imctk_abc_sys"] + pub fn Gia_ObjChild2(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjFaninId0_imctk_abc_sys"] + pub fn Gia_ObjFaninId0( + pObj: *mut Gia_Obj_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId1_imctk_abc_sys"] + pub fn Gia_ObjFaninId1( + pObj: *mut Gia_Obj_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId2_imctk_abc_sys"] + pub fn Gia_ObjFaninId2( + p: *mut Gia_Man_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId_imctk_abc_sys"] + pub fn Gia_ObjFaninId( + pObj: *mut Gia_Obj_t, + ObjId: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId0p_imctk_abc_sys"] + pub fn Gia_ObjFaninId0p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId1p_imctk_abc_sys"] + pub fn Gia_ObjFaninId1p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninId2p_imctk_abc_sys"] + pub fn Gia_ObjFaninId2p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninIdp_imctk_abc_sys"] + pub fn Gia_ObjFaninIdp( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit0_imctk_abc_sys"] + pub fn Gia_ObjFaninLit0( + pObj: *mut Gia_Obj_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit1_imctk_abc_sys"] + pub fn Gia_ObjFaninLit1( + pObj: *mut Gia_Obj_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit2_imctk_abc_sys"] + pub fn Gia_ObjFaninLit2( + p: *mut Gia_Man_t, + ObjId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit0p_imctk_abc_sys"] + pub fn Gia_ObjFaninLit0p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit1p_imctk_abc_sys"] + pub fn Gia_ObjFaninLit1p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFaninLit2p_imctk_abc_sys"] + pub fn Gia_ObjFaninLit2p(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFlipFaninC0_imctk_abc_sys"] + pub fn Gia_ObjFlipFaninC0(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjFaninNum_imctk_abc_sys"] + pub fn Gia_ObjFaninNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjWhatFanin_imctk_abc_sys"] + pub fn Gia_ObjWhatFanin( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + pFanin: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManCoDriverId_imctk_abc_sys"] + pub fn Gia_ManCoDriverId( + p: *mut Gia_Man_t, + iCoIndex: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPoIsConst_imctk_abc_sys"] + pub fn Gia_ManPoIsConst( + p: *mut Gia_Man_t, + iPoIndex: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPoIsConst0_imctk_abc_sys"] + pub fn Gia_ManPoIsConst0( + p: *mut Gia_Man_t, + iPoIndex: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPoIsConst1_imctk_abc_sys"] + pub fn Gia_ManPoIsConst1( + p: *mut Gia_Man_t, + iPoIndex: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCopy_imctk_abc_sys"] + pub fn Gia_ObjCopy(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjLitCopy_imctk_abc_sys"] + pub fn Gia_ObjLitCopy(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin0Copy_imctk_abc_sys"] + pub fn Gia_ObjFanin0Copy(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin1Copy_imctk_abc_sys"] + pub fn Gia_ObjFanin1Copy(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin2Copy_imctk_abc_sys"] + pub fn Gia_ObjFanin2Copy(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCopyF_imctk_abc_sys"] + pub fn Gia_ObjCopyF( + p: *mut Gia_Man_t, + f: ::std::os::raw::c_int, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetCopyF_imctk_abc_sys"] + pub fn Gia_ObjSetCopyF( + p: *mut Gia_Man_t, + f: ::std::os::raw::c_int, + pObj: *mut Gia_Obj_t, + iLit: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ObjCopyArray_imctk_abc_sys"] + pub fn Gia_ObjCopyArray( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetCopyArray_imctk_abc_sys"] + pub fn Gia_ObjSetCopyArray( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + iLit: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ManCleanCopyArray_imctk_abc_sys"] + pub fn Gia_ManCleanCopyArray(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ObjCopy2Array_imctk_abc_sys"] + pub fn Gia_ObjCopy2Array( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetCopy2Array_imctk_abc_sys"] + pub fn Gia_ObjSetCopy2Array( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + iLit: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ManCleanCopy2Array_imctk_abc_sys"] + pub fn Gia_ManCleanCopy2Array(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ObjFanin0CopyF_imctk_abc_sys"] + pub fn Gia_ObjFanin0CopyF( + p: *mut Gia_Man_t, + f: ::std::os::raw::c_int, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin1CopyF_imctk_abc_sys"] + pub fn Gia_ObjFanin1CopyF( + p: *mut Gia_Man_t, + f: ::std::os::raw::c_int, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin0CopyArray_imctk_abc_sys"] + pub fn Gia_ObjFanin0CopyArray(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanin1CopyArray_imctk_abc_sys"] + pub fn Gia_ObjFanin1CopyArray(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFromLit_imctk_abc_sys"] + pub fn Gia_ObjFromLit(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjToLit_imctk_abc_sys"] + pub fn Gia_ObjToLit(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjPhaseRealLit_imctk_abc_sys"] + pub fn Gia_ObjPhaseRealLit( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLevelId_imctk_abc_sys"] + pub fn Gia_ObjLevelId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLevel_imctk_abc_sys"] + pub fn Gia_ObjLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjUpdateLevelId_imctk_abc_sys"] + pub fn Gia_ObjUpdateLevelId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + l: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ObjSetLevelId_imctk_abc_sys"] + pub fn Gia_ObjSetLevelId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + l: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ObjSetLevel_imctk_abc_sys"] + pub fn Gia_ObjSetLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, l: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjSetCoLevel_imctk_abc_sys"] + pub fn Gia_ObjSetCoLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetBufLevel_imctk_abc_sys"] + pub fn Gia_ObjSetBufLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetAndLevel_imctk_abc_sys"] + pub fn Gia_ObjSetAndLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetXorLevel_imctk_abc_sys"] + pub fn Gia_ObjSetXorLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetMuxLevel_imctk_abc_sys"] + pub fn Gia_ObjSetMuxLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetGateLevel_imctk_abc_sys"] + pub fn Gia_ObjSetGateLevel(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjHasNumId_imctk_abc_sys"] + pub fn Gia_ObjHasNumId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjNumId_imctk_abc_sys"] + pub fn Gia_ObjNumId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjNum_imctk_abc_sys"] + pub fn Gia_ObjNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetNumId_imctk_abc_sys"] + pub fn Gia_ObjSetNumId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, n: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjSetNum_imctk_abc_sys"] + pub fn Gia_ObjSetNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, n: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjResetNumId_imctk_abc_sys"] + pub fn Gia_ObjResetNumId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjRefNumId_imctk_abc_sys"] + pub fn Gia_ObjRefNumId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefIncId_imctk_abc_sys"] + pub fn Gia_ObjRefIncId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefDecId_imctk_abc_sys"] + pub fn Gia_ObjRefDecId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefNum_imctk_abc_sys"] + pub fn Gia_ObjRefNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefInc_imctk_abc_sys"] + pub fn Gia_ObjRefInc(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefDec_imctk_abc_sys"] + pub fn Gia_ObjRefDec(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjRefFanin0Inc_imctk_abc_sys"] + pub fn Gia_ObjRefFanin0Inc(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjRefFanin1Inc_imctk_abc_sys"] + pub fn Gia_ObjRefFanin1Inc(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjRefFanin2Inc_imctk_abc_sys"] + pub fn Gia_ObjRefFanin2Inc(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjRefFanin0Dec_imctk_abc_sys"] + pub fn Gia_ObjRefFanin0Dec(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjRefFanin1Dec_imctk_abc_sys"] + pub fn Gia_ObjRefFanin1Dec(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjRefFanin2Dec_imctk_abc_sys"] + pub fn Gia_ObjRefFanin2Dec(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjLutRefNumId_imctk_abc_sys"] + pub fn Gia_ObjLutRefNumId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutRefIncId_imctk_abc_sys"] + pub fn Gia_ObjLutRefIncId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutRefDecId_imctk_abc_sys"] + pub fn Gia_ObjLutRefDecId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutRefNum_imctk_abc_sys"] + pub fn Gia_ObjLutRefNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutRefInc_imctk_abc_sys"] + pub fn Gia_ObjLutRefInc(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutRefDec_imctk_abc_sys"] + pub fn Gia_ObjLutRefDec(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetTravIdCurrent_imctk_abc_sys"] + pub fn Gia_ObjSetTravIdCurrent(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjSetTravIdPrevious_imctk_abc_sys"] + pub fn Gia_ObjSetTravIdPrevious(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjIsTravIdCurrent_imctk_abc_sys"] + pub fn Gia_ObjIsTravIdCurrent(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsTravIdPrevious_imctk_abc_sys"] + pub fn Gia_ObjIsTravIdPrevious( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjUpdateTravIdCurrent_imctk_abc_sys"] + pub fn Gia_ObjUpdateTravIdCurrent( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjUpdateTravIdPrevious_imctk_abc_sys"] + pub fn Gia_ObjUpdateTravIdPrevious( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetTravIdCurrentId_imctk_abc_sys"] + pub fn Gia_ObjSetTravIdCurrentId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjSetTravIdPreviousId_imctk_abc_sys"] + pub fn Gia_ObjSetTravIdPreviousId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjIsTravIdCurrentId_imctk_abc_sys"] + pub fn Gia_ObjIsTravIdCurrentId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsTravIdPreviousId_imctk_abc_sys"] + pub fn Gia_ObjIsTravIdPreviousId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjUpdateTravIdCurrentId_imctk_abc_sys"] + pub fn Gia_ObjUpdateTravIdCurrentId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjUpdateTravIdPreviousId_imctk_abc_sys"] + pub fn Gia_ObjUpdateTravIdPreviousId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManTimeClean_imctk_abc_sys"] + pub fn Gia_ManTimeClean(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ManTimeStart_imctk_abc_sys"] + pub fn Gia_ManTimeStart(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ManTimeStop_imctk_abc_sys"] + pub fn Gia_ManTimeStop(p: *mut Gia_Man_t); +} +extern "C" { + #[link_name = "Gia_ObjTimeArrival_imctk_abc_sys"] + pub fn Gia_ObjTimeArrival(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjTimeRequired_imctk_abc_sys"] + pub fn Gia_ObjTimeRequired(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjTimeSlack_imctk_abc_sys"] + pub fn Gia_ObjTimeSlack(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjTimeArrivalObj_imctk_abc_sys"] + pub fn Gia_ObjTimeArrivalObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjTimeRequiredObj_imctk_abc_sys"] + pub fn Gia_ObjTimeRequiredObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjTimeSlackObj_imctk_abc_sys"] + pub fn Gia_ObjTimeSlackObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> f32; +} +extern "C" { + #[link_name = "Gia_ObjSetTimeArrival_imctk_abc_sys"] + pub fn Gia_ObjSetTimeArrival(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSetTimeRequired_imctk_abc_sys"] + pub fn Gia_ObjSetTimeRequired(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSetTimeSlack_imctk_abc_sys"] + pub fn Gia_ObjSetTimeSlack(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSetTimeArrivalObj_imctk_abc_sys"] + pub fn Gia_ObjSetTimeArrivalObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSetTimeRequiredObj_imctk_abc_sys"] + pub fn Gia_ObjSetTimeRequiredObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSetTimeSlackObj_imctk_abc_sys"] + pub fn Gia_ObjSetTimeSlackObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, t: f32); +} +extern "C" { + #[link_name = "Gia_ObjSimWords_imctk_abc_sys"] + pub fn Gia_ObjSimWords(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSimPi_imctk_abc_sys"] + pub fn Gia_ObjSimPi(p: *mut Gia_Man_t, PiId: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Gia_ObjSim_imctk_abc_sys"] + pub fn Gia_ObjSim(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> *mut word; +} +extern "C" { + #[link_name = "Gia_ObjSimObj_imctk_abc_sys"] + pub fn Gia_ObjSimObj(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut word; +} +extern "C" { + pub fn Gia_ObjAddFanout(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, pFanout: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ManAppendObj_imctk_abc_sys"] + pub fn Gia_ManAppendObj(p: *mut Gia_Man_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ManAppendCi_imctk_abc_sys"] + pub fn Gia_ManAppendCi(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManQuantSetSuppAnd(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManBuiltInSimPerform(p: *mut Gia_Man_t, iObj: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ManAppendAnd_imctk_abc_sys"] + pub fn Gia_ManAppendAnd( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendXorReal_imctk_abc_sys"] + pub fn Gia_ManAppendXorReal( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendMuxReal_imctk_abc_sys"] + pub fn Gia_ManAppendMuxReal( + p: *mut Gia_Man_t, + iLitC: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + iLit0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendBuf_imctk_abc_sys"] + pub fn Gia_ManAppendBuf( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendCo_imctk_abc_sys"] + pub fn Gia_ManAppendCo( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendOr_imctk_abc_sys"] + pub fn Gia_ManAppendOr( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendMux_imctk_abc_sys"] + pub fn Gia_ManAppendMux( + p: *mut Gia_Man_t, + iCtrl: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendMaj_imctk_abc_sys"] + pub fn Gia_ManAppendMaj( + p: *mut Gia_Man_t, + iData0: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendXor_imctk_abc_sys"] + pub fn Gia_ManAppendXor( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendAnd2_imctk_abc_sys"] + pub fn Gia_ManAppendAnd2( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendOr2_imctk_abc_sys"] + pub fn Gia_ManAppendOr2( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendMux2_imctk_abc_sys"] + pub fn Gia_ManAppendMux2( + p: *mut Gia_Man_t, + iCtrl: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendMaj2_imctk_abc_sys"] + pub fn Gia_ManAppendMaj2( + p: *mut Gia_Man_t, + iData0: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendXor2_imctk_abc_sys"] + pub fn Gia_ManAppendXor2( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManAppendXorReal2_imctk_abc_sys"] + pub fn Gia_ManAppendXorReal2( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManPatchCoDriver_imctk_abc_sys"] + pub fn Gia_ManPatchCoDriver( + p: *mut Gia_Man_t, + iCoIndex: ::std::os::raw::c_int, + iLit0: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_XsimNotCond_imctk_abc_sys"] + pub fn Gia_XsimNotCond( + Value: ::std::os::raw::c_int, + fCompl: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_XsimAndCond_imctk_abc_sys"] + pub fn Gia_XsimAndCond( + Value0: ::std::os::raw::c_int, + fCompl0: ::std::os::raw::c_int, + Value1: ::std::os::raw::c_int, + fCompl1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimSetC_imctk_abc_sys"] + pub fn Gia_ObjTerSimSetC(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimSet0_imctk_abc_sys"] + pub fn Gia_ObjTerSimSet0(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimSet1_imctk_abc_sys"] + pub fn Gia_ObjTerSimSet1(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimSetX_imctk_abc_sys"] + pub fn Gia_ObjTerSimSetX(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimGetC_imctk_abc_sys"] + pub fn Gia_ObjTerSimGetC(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet0_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet1_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet1(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGetX_imctk_abc_sys"] + pub fn Gia_ObjTerSimGetX(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet0Fanin0_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet0Fanin0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet1Fanin0_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet1Fanin0(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet0Fanin1_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet0Fanin1(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimGet1Fanin1_imctk_abc_sys"] + pub fn Gia_ObjTerSimGet1Fanin1(pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjTerSimAnd_imctk_abc_sys"] + pub fn Gia_ObjTerSimAnd(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimCo_imctk_abc_sys"] + pub fn Gia_ObjTerSimCo(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimRo_imctk_abc_sys"] + pub fn Gia_ObjTerSimRo(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_ObjTerSimPrint_imctk_abc_sys"] + pub fn Gia_ObjTerSimPrint(pObj: *mut Gia_Obj_t); +} +extern "C" { + #[link_name = "Gia_AigerReadInt_imctk_abc_sys"] + pub fn Gia_AigerReadInt(pPos: *mut ::std::os::raw::c_uchar) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_AigerWriteInt_imctk_abc_sys"] + pub fn Gia_AigerWriteInt(pPos: *mut ::std::os::raw::c_uchar, Value: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_AigerReadUnsigned_imctk_abc_sys"] + pub fn Gia_AigerReadUnsigned( + ppPos: *mut *mut ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_uint; +} +extern "C" { + #[link_name = "Gia_AigerWriteUnsigned_imctk_abc_sys"] + pub fn Gia_AigerWriteUnsigned(vStr: *mut Vec_Str_t, x: ::std::os::raw::c_uint); +} +extern "C" { + #[link_name = "Gia_AigerWriteUnsignedFile_imctk_abc_sys"] + pub fn Gia_AigerWriteUnsignedFile(pFile: *mut FILE, x: ::std::os::raw::c_uint); +} +extern "C" { + #[link_name = "Gia_AigerWriteUnsignedBuffer_imctk_abc_sys"] + pub fn Gia_AigerWriteUnsignedBuffer( + pBuffer: *mut ::std::os::raw::c_uchar, + Pos: ::std::os::raw::c_int, + x: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjReprObj_imctk_abc_sys"] + pub fn Gia_ObjReprObj(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjRepr_imctk_abc_sys"] + pub fn Gia_ObjRepr(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetRepr_imctk_abc_sys"] + pub fn Gia_ObjSetRepr(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, Num: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjSetReprRev_imctk_abc_sys"] + pub fn Gia_ObjSetReprRev( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + Num: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ObjUnsetRepr_imctk_abc_sys"] + pub fn Gia_ObjUnsetRepr(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjHasRepr_imctk_abc_sys"] + pub fn Gia_ObjHasRepr(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjReprSelf_imctk_abc_sys"] + pub fn Gia_ObjReprSelf(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSibl_imctk_abc_sys"] + pub fn Gia_ObjSibl(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSiblObj_imctk_abc_sys"] + pub fn Gia_ObjSiblObj(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjProved_imctk_abc_sys"] + pub fn Gia_ObjProved(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetProved_imctk_abc_sys"] + pub fn Gia_ObjSetProved(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjUnsetProved_imctk_abc_sys"] + pub fn Gia_ObjUnsetProved(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjFailed_imctk_abc_sys"] + pub fn Gia_ObjFailed(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetFailed_imctk_abc_sys"] + pub fn Gia_ObjSetFailed(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjColor_imctk_abc_sys"] + pub fn Gia_ObjColor( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + c: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjColors_imctk_abc_sys"] + pub fn Gia_ObjColors(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetColor_imctk_abc_sys"] + pub fn Gia_ObjSetColor(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, c: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjSetColors_imctk_abc_sys"] + pub fn Gia_ObjSetColors(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjVisitColor_imctk_abc_sys"] + pub fn Gia_ObjVisitColor( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + c: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjDiffColors_imctk_abc_sys"] + pub fn Gia_ObjDiffColors( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + j: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjDiffColors2_imctk_abc_sys"] + pub fn Gia_ObjDiffColors2( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + j: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjNextObj_imctk_abc_sys"] + pub fn Gia_ObjNextObj(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjNext_imctk_abc_sys"] + pub fn Gia_ObjNext(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjSetNext_imctk_abc_sys"] + pub fn Gia_ObjSetNext(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int, Num: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjIsConst_imctk_abc_sys"] + pub fn Gia_ObjIsConst(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsHead_imctk_abc_sys"] + pub fn Gia_ObjIsHead(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsNone_imctk_abc_sys"] + pub fn Gia_ObjIsNone(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsTail_imctk_abc_sys"] + pub fn Gia_ObjIsTail(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsClass_imctk_abc_sys"] + pub fn Gia_ObjIsClass(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjHasSameRepr_imctk_abc_sys"] + pub fn Gia_ObjHasSameRepr( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsFailedPair_imctk_abc_sys"] + pub fn Gia_ObjIsFailedPair( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + k: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ClassIsPair_imctk_abc_sys"] + pub fn Gia_ClassIsPair(p: *mut Gia_Man_t, i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ClassUndoPair_imctk_abc_sys"] + pub fn Gia_ClassUndoPair(p: *mut Gia_Man_t, i: ::std::os::raw::c_int); +} +extern "C" { + #[link_name = "Gia_ObjFoffsetId_imctk_abc_sys"] + pub fn Gia_ObjFoffsetId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFoffset_imctk_abc_sys"] + pub fn Gia_ObjFoffset(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanoutNumId_imctk_abc_sys"] + pub fn Gia_ObjFanoutNumId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanoutNum_imctk_abc_sys"] + pub fn Gia_ObjFanoutNum(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanoutId_imctk_abc_sys"] + pub fn Gia_ObjFanoutId( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjFanout0_imctk_abc_sys"] + pub fn Gia_ObjFanout0(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjFanout_imctk_abc_sys"] + pub fn Gia_ObjFanout( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + i: ::std::os::raw::c_int, + ) -> *mut Gia_Obj_t; +} +extern "C" { + #[link_name = "Gia_ObjSetFanout_imctk_abc_sys"] + pub fn Gia_ObjSetFanout( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + i: ::std::os::raw::c_int, + pFan: *mut Gia_Obj_t, + ); +} +extern "C" { + #[link_name = "Gia_ObjSetFanoutInt_imctk_abc_sys"] + pub fn Gia_ObjSetFanoutInt( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + i: ::std::os::raw::c_int, + x: ::std::os::raw::c_int, + ); +} +extern "C" { + #[link_name = "Gia_ManHasMapping_imctk_abc_sys"] + pub fn Gia_ManHasMapping(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsLut_imctk_abc_sys"] + pub fn Gia_ObjIsLut(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutSize_imctk_abc_sys"] + pub fn Gia_ObjLutSize(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutFanins_imctk_abc_sys"] + pub fn Gia_ObjLutFanins( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutFanin_imctk_abc_sys"] + pub fn Gia_ObjLutFanin( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutMuxId_imctk_abc_sys"] + pub fn Gia_ObjLutMuxId(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutIsMux_imctk_abc_sys"] + pub fn Gia_ObjLutIsMux(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManHasMapping2_imctk_abc_sys"] + pub fn Gia_ManHasMapping2(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsLut2_imctk_abc_sys"] + pub fn Gia_ObjIsLut2(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutSize2_imctk_abc_sys"] + pub fn Gia_ObjLutSize2(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutFanins2_imctk_abc_sys"] + pub fn Gia_ObjLutFanins2(p: *mut Gia_Man_t, Id: ::std::os::raw::c_int) -> *mut Vec_Int_t; +} +extern "C" { + #[link_name = "Gia_ObjLutFanin2_imctk_abc_sys"] + pub fn Gia_ObjLutFanin2( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutFanoutNum2_imctk_abc_sys"] + pub fn Gia_ObjLutFanoutNum2( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjLutFanout2_imctk_abc_sys"] + pub fn Gia_ObjLutFanout2( + p: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ManHasCellMapping_imctk_abc_sys"] + pub fn Gia_ManHasCellMapping(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCell_imctk_abc_sys"] + pub fn Gia_ObjIsCell(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCellInv_imctk_abc_sys"] + pub fn Gia_ObjIsCellInv( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjIsCellBuf_imctk_abc_sys"] + pub fn Gia_ObjIsCellBuf( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCellSize_imctk_abc_sys"] + pub fn Gia_ObjCellSize(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCellFanins_imctk_abc_sys"] + pub fn Gia_ObjCellFanins( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCellFanin_imctk_abc_sys"] + pub fn Gia_ObjCellFanin( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + i: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "Gia_ObjCellId_imctk_abc_sys"] + pub fn Gia_ObjCellId(p: *mut Gia_Man_t, iLit: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_FileSize(pFileName: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_AigerReadFromMemory( + pContents: *mut ::std::os::raw::c_char, + nFileSize: ::std::os::raw::c_int, + fGiaSimple: ::std::os::raw::c_int, + fSkipStrash: ::std::os::raw::c_int, + fCheck: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_AigerRead( + pFileName: *mut ::std::os::raw::c_char, + fGiaSimple: ::std::os::raw::c_int, + fSkipStrash: ::std::os::raw::c_int, + fCheck: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_AigerWrite( + p: *mut Gia_Man_t, + pFileName: *mut ::std::os::raw::c_char, + fWriteSymbols: ::std::os::raw::c_int, + fCompact: ::std::os::raw::c_int, + fWriteNewLine: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_AigerWriteS( + p: *mut Gia_Man_t, + pFileName: *mut ::std::os::raw::c_char, + fWriteSymbols: ::std::os::raw::c_int, + fCompact: ::std::os::raw::c_int, + fWriteNewLine: ::std::os::raw::c_int, + fSkipComment: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_DumpAiger( + p: *mut Gia_Man_t, + pFilePrefix: *mut ::std::os::raw::c_char, + iFileNum: ::std::os::raw::c_int, + nFileNumDigits: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_AigerWriteIntoMemoryStr(p: *mut Gia_Man_t) -> *mut Vec_Str_t; +} +extern "C" { + pub fn Gia_AigerWriteIntoMemoryStrPart( + p: *mut Gia_Man_t, + vCis: *mut Vec_Int_t, + vAnds: *mut Vec_Int_t, + vCos: *mut Vec_Int_t, + nRegs: ::std::os::raw::c_int, + ) -> *mut Vec_Str_t; +} +extern "C" { + pub fn Gia_AigerWriteSimple(pInit: *mut Gia_Man_t, pFileName: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_ManBalance( + p: *mut Gia_Man_t, + fSimpleAnd: ::std::os::raw::c_int, + fStrict: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManAreaBalance( + p: *mut Gia_Man_t, + fSimpleAnd: ::std::os::raw::c_int, + nNewNodesMax: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManAigSyn2( + p: *mut Gia_Man_t, + fOldAlgo: ::std::os::raw::c_int, + fCoarsen: ::std::os::raw::c_int, + fCutMin: ::std::os::raw::c_int, + nRelaxRatio: ::std::os::raw::c_int, + fDelayMin: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManAigSyn3( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManAigSyn4( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManConvertAigToTruth( + p: *mut Gia_Man_t, + pRoot: *mut Gia_Obj_t, + vLeaves: *mut Vec_Int_t, + vTruth: *mut Vec_Int_t, + vVisited: *mut Vec_Int_t, + ) -> *mut ::std::os::raw::c_uint; +} +extern "C" { + pub fn Gia_ManPerformBidec( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManVerifyCex( + pAig: *mut Gia_Man_t, + p: *mut Abc_Cex_t, + fDualOut: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFindFailedPoCex( + pAig: *mut Gia_Man_t, + p: *mut Abc_Cex_t, + nOutputs: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManSetFailedPoCex(pAig: *mut Gia_Man_t, p: *mut Abc_Cex_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCounterExampleValueStart(pGia: *mut Gia_Man_t, pCex: *mut Abc_Cex_t); +} +extern "C" { + pub fn Gia_ManCounterExampleValueStop(pGia: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCounterExampleValueLookup( + pGia: *mut Gia_Man_t, + Id: ::std::os::raw::c_int, + iFrame: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCexExtendToIncludeCurrentStates( + p: *mut Gia_Man_t, + pCex: *mut Abc_Cex_t, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Gia_ManCexExtendToIncludeAllObjects( + p: *mut Gia_Man_t, + pCex: *mut Abc_Cex_t, + ) -> *mut Abc_Cex_t; +} +extern "C" { + pub fn Cbs_ManSolveMiter( + pGia: *mut Gia_Man_t, + nConfs: ::std::os::raw::c_int, + pvStatus: *mut *mut Vec_Str_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cbs_Man_t_ { + _unused: [u8; 0], +} +pub type Cbs_Man_t = Cbs_Man_t_; +extern "C" { + pub fn Cbs_ManAlloc(pGia: *mut Gia_Man_t) -> *mut Cbs_Man_t; +} +extern "C" { + pub fn Cbs_ManStop(p: *mut Cbs_Man_t); +} +extern "C" { + pub fn Cbs_ManSolve(p: *mut Cbs_Man_t, pObj: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cbs_ManSolve2( + p: *mut Cbs_Man_t, + pObj: *mut Gia_Obj_t, + pObj2: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cbs_ManSolveMiterNc( + pGia: *mut Gia_Man_t, + nConfs: ::std::os::raw::c_int, + pvStatus: *mut *mut Vec_Str_t, + f0Proved: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Cbs_ManSetConflictNum(p: *mut Cbs_Man_t, Num: ::std::os::raw::c_int); +} +extern "C" { + pub fn Cbs_ReadModel(p: *mut Cbs_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Tas_ManSolveMiterNc( + pGia: *mut Gia_Man_t, + nConfs: ::std::os::raw::c_int, + pvStatus: *mut *mut Vec_Str_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManPrintFanio(pGia: *mut Gia_Man_t, nNodes: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManDupCof(p: *mut Gia_Man_t, iVar: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCofAllInt( + p: *mut Gia_Man_t, + vSigs: *mut Vec_Int_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCofAll( + p: *mut Gia_Man_t, + nFanLim: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ResubVarNum(vResub: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ResubToTruth6(vResub: *mut Vec_Int_t) -> word; +} +extern "C" { + pub fn Gia_ManEvalSolutionOne( + p: *mut Gia_Man_t, + vSims: *mut Vec_Wrd_t, + vIsfs: *mut Vec_Wrd_t, + vCands: *mut Vec_Int_t, + vSet: *mut Vec_Int_t, + nWords: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDeriveSolutionOne( + p: *mut Gia_Man_t, + vSims: *mut Vec_Wrd_t, + vIsfs: *mut Vec_Wrd_t, + vCands: *mut Vec_Int_t, + vSet: *mut Vec_Int_t, + nWords: ::std::os::raw::c_int, + Type: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCollectCis( + p: *mut Gia_Man_t, + pNodes: *mut ::std::os::raw::c_int, + nNodes: ::std::os::raw::c_int, + vSupp: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManCollectAnds_rec( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + vNodes: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManCollectAnds( + p: *mut Gia_Man_t, + pNodes: *mut ::std::os::raw::c_int, + nNodes: ::std::os::raw::c_int, + vNodes: *mut Vec_Int_t, + vLeaves: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManCollectAndsAll(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCollectNodesCis( + p: *mut Gia_Man_t, + pNodes: *mut ::std::os::raw::c_int, + nNodes: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManSuppSize( + p: *mut Gia_Man_t, + pNodes: *mut ::std::os::raw::c_int, + nNodes: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManConeSize( + p: *mut Gia_Man_t, + pNodes: *mut ::std::os::raw::c_int, + nNodes: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLevelize(p: *mut Gia_Man_t) -> *mut Vec_Vec_t; +} +extern "C" { + pub fn Gia_ManLevelizeR(p: *mut Gia_Man_t) -> *mut Vec_Wec_t; +} +extern "C" { + pub fn Gia_ManOrderReverse(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCollectTfi(p: *mut Gia_Man_t, vRoots: *mut Vec_Int_t, vNodes: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManCollectTfo(p: *mut Gia_Man_t, vRoots: *mut Vec_Int_t, vNodes: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManDupRemapLiterals(vLits: *mut Vec_Int_t, p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDupRemapEquiv(pNew: *mut Gia_Man_t, p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDupOrderDfs(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOrderDfsChoices(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOrderDfsReverse( + p: *mut Gia_Man_t, + fRevFans: ::std::os::raw::c_int, + fRevOuts: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOutputGroup( + p: *mut Gia_Man_t, + iOutStart: ::std::os::raw::c_int, + iOutStop: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOutputVec(p: *mut Gia_Man_t, vOutPres: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupSelectedOutputs( + p: *mut Gia_Man_t, + vOutsLeft: *mut Vec_Int_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOrderAiger(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupLastPis(p: *mut Gia_Man_t, nLastPis: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupFlip( + p: *mut Gia_Man_t, + pInitState: *mut ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCycled( + pAig: *mut Gia_Man_t, + pCex: *mut Abc_Cex_t, + nFrames: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDup(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupNoBuf(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupMap(p: *mut Gia_Man_t, vMap: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDup2(p1: *mut Gia_Man_t, p2: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupWithAttributes(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupRemovePis(p: *mut Gia_Man_t, nRemPis: ::std::os::raw::c_int) + -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupZero(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupPerm(p: *mut Gia_Man_t, vPiPerm: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupPermFlop(p: *mut Gia_Man_t, vFfPerm: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupPermFlopGap(p: *mut Gia_Man_t, vFfPerm: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAppend(p: *mut Gia_Man_t, pTwo: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDupAppendShare(p: *mut Gia_Man_t, pTwo: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDupAppendNew(pOne: *mut Gia_Man_t, pTwo: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAppendCones( + p: *mut Gia_Man_t, + ppCones: *mut *mut Gia_Man_t, + nCones: ::std::os::raw::c_int, + fOnlyRegs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupSelf(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupFlopClass(p: *mut Gia_Man_t, iClass: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupMarked(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupTimes(p: *mut Gia_Man_t, nTimes: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfs(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsOnePo(p: *mut Gia_Man_t, iPo: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsRehash(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCofactorVar( + p: *mut Gia_Man_t, + iVar: ::std::os::raw::c_int, + Value: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCofactorObj( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + Value: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupMux( + iVar: ::std::os::raw::c_int, + pCof1: *mut Gia_Man_t, + pCof0: *mut Gia_Man_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupBlock(p: *mut Gia_Man_t, nBlock: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupExist(p: *mut Gia_Man_t, iVar: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupUniv(p: *mut Gia_Man_t, iVar: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsSkip(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsCone(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupConeSupp( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + vCiIds: *mut Vec_Int_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupConeBack( + p: *mut Gia_Man_t, + pNew: *mut Gia_Man_t, + vCiIds: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDupConeBackObjs( + p: *mut Gia_Man_t, + pNew: *mut Gia_Man_t, + vObjs: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDupDfsNode(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsLitArray(p: *mut Gia_Man_t, vLits: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupTrimmed( + p: *mut Gia_Man_t, + fTrimCis: ::std::os::raw::c_int, + fTrimCos: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + OutValue: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOntop(p: *mut Gia_Man_t, p2: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupWithNewPo(p1: *mut Gia_Man_t, p2: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsCiMap( + p: *mut Gia_Man_t, + pCi2Lit: *mut ::std::os::raw::c_int, + vLits: *mut Vec_Int_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPermuteInputs( + p: *mut Gia_Man_t, + nPpis: ::std::os::raw::c_int, + nExtra: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDfsClasses(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupTopAnd(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManMiter( + pAig0: *mut Gia_Man_t, + pAig1: *mut Gia_Man_t, + nInsDup: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + fSeq: ::std::os::raw::c_int, + fImplic: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManMiterInverse( + pBot: *mut Gia_Man_t, + pTop: *mut Gia_Man_t, + fDualOut: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAndOr( + p: *mut Gia_Man_t, + nOuts: ::std::os::raw::c_int, + fUseOr: ::std::os::raw::c_int, + fCompl: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupZeroUndc( + p: *mut Gia_Man_t, + pInit: *mut ::std::os::raw::c_char, + nNewPis: ::std::os::raw::c_int, + fGiaSimple: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManMiter2( + p: *mut Gia_Man_t, + pInit: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransformMiter(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransformMiter2(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransformToDual(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransformTwoWord2DualOutput(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManChoiceMiter(vGias: *mut Vec_Ptr_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupWithConstraints(p: *mut Gia_Man_t, vPoTypes: *mut Vec_Int_t) + -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCones( + p: *mut Gia_Man_t, + pPos: *mut ::std::os::raw::c_int, + nPos: ::std::os::raw::c_int, + fTrimPis: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAndCones( + p: *mut Gia_Man_t, + pAnds: *mut ::std::os::raw::c_int, + nAnds: ::std::os::raw::c_int, + fTrimPis: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAndConesLimit( + p: *mut Gia_Man_t, + pAnds: *mut ::std::os::raw::c_int, + nAnds: ::std::os::raw::c_int, + Level: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupAndConesLimit2( + p: *mut Gia_Man_t, + pAnds: *mut ::std::os::raw::c_int, + nAnds: ::std::os::raw::c_int, + Level: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupOneHot(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupLevelized(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupFromVecs( + p: *mut Gia_Man_t, + vCis: *mut Vec_Int_t, + vAnds: *mut Vec_Int_t, + vCos: *mut Vec_Int_t, + nRegs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupSliced(p: *mut Gia_Man_t, nSuppMax: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupDemiter(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDemiterToDual(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDemiterDual( + p: *mut Gia_Man_t, + pp0: *mut *mut Gia_Man_t, + pp1: *mut *mut Gia_Man_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDemiterTwoWords( + p: *mut Gia_Man_t, + pp0: *mut *mut Gia_Man_t, + pp1: *mut *mut Gia_Man_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManProdAdderGen( + nArgA: ::std::os::raw::c_int, + nArgB: ::std::os::raw::c_int, + Seed: ::std::os::raw::c_int, + fSigned: ::std::os::raw::c_int, + fCla: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManEdgeFromArray(p: *mut Gia_Man_t, vArray: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManEdgeToArray(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManConvertPackingToEdges(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ObjCheckEdge( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + iNext: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEvalEdgeDelay(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEvalEdgeCount(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManComputeEdgeDelay( + p: *mut Gia_Man_t, + fUseTwo: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManComputeEdgeDelay2(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManUpdateMapping(p: *mut Gia_Man_t, vNodes: *mut Vec_Int_t, vWin: *mut Vec_Wec_t); +} +extern "C" { + pub fn Gia_ManEvalWindow( + p: *mut Gia_Man_t, + vLeaves: *mut Vec_Int_t, + vNodes: *mut Vec_Int_t, + vWin: *mut Vec_Wec_t, + vTemp: *mut Vec_Int_t, + fUseTwo: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDetectSeqSignals( + p: *mut Gia_Man_t, + fSetReset: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManUnrollAndCofactor( + p: *mut Gia_Man_t, + nFrames: ::std::os::raw::c_int, + nFanMax: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManRemoveEnables(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManOrigIdsInit(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManOrigIdsStart(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManOrigIdsRemap(p: *mut Gia_Man_t, pNew: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManOrigIdsReduce(p: *mut Gia_Man_t, vPairs: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManComputeGiaEquivs( + pGia: *mut Gia_Man_t, + nConfs: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManEquivFixOutputPairs(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCheckTopoOrder(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDeriveNexts(p: *mut Gia_Man_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManDeriveReprs(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManEquivCountLits(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEquivCountLitsAll(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEquivCountClasses(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEquivPrintOne( + p: *mut Gia_Man_t, + i: ::std::os::raw::c_int, + Counter: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManEquivPrintClasses(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int, Mem: f32); +} +extern "C" { + pub fn Gia_ManEquivReduce( + p: *mut Gia_Man_t, + fUseAll: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + fSkipPhase: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManEquivReduceAndRemap( + p: *mut Gia_Man_t, + fSeq: ::std::os::raw::c_int, + fMiterPairs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManEquivSetColors( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManSpecReduce( + p: *mut Gia_Man_t, + fDualOut: ::std::os::raw::c_int, + fSynthesis: ::std::os::raw::c_int, + fReduce: ::std::os::raw::c_int, + fSkipSome: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManSpecReduceInit( + p: *mut Gia_Man_t, + pInit: *mut Abc_Cex_t, + nFrames: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManSpecReduceInitFrames( + p: *mut Gia_Man_t, + pInit: *mut Abc_Cex_t, + nFramesMax: ::std::os::raw::c_int, + pnFrames: *mut ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + nMinOutputs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManEquivTransform(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManEquivImprove(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManEquivToChoices( + p: *mut Gia_Man_t, + nSnapshots: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManCountChoiceNodes(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCountChoices(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFilterEquivsForSpeculation( + pGia: *mut Gia_Man_t, + pName1: *mut ::std::os::raw::c_char, + pName2: *mut ::std::os::raw::c_char, + fLatchA: ::std::os::raw::c_int, + fLatchB: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFilterEquivsUsingParts( + pGia: *mut Gia_Man_t, + pName1: *mut ::std::os::raw::c_char, + pName2: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFilterEquivsUsingLatches( + pGia: *mut Gia_Man_t, + fFlopsOnly: ::std::os::raw::c_int, + fFlopsWith: ::std::os::raw::c_int, + fUseRiDrivers: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManQuantSetSuppStart(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManQuantSetSuppZero(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManQuantSetSuppCi(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManQuantUpdateCiSupp(p: *mut Gia_Man_t, iObj: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManQuantExist( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + pFuncCiToKeep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ObjRemoveFanout(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t, pFanout: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManFanoutStart(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManFanoutStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManStaticFanoutStart(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManStaticFanoutStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManStaticMappingFanoutStart(p: *mut Gia_Man_t, pvIndex: *mut *mut Vec_Int_t); +} +extern "C" { + pub fn For_ManExperiment( + pGia: *mut Gia_Man_t, + nIters: ::std::os::raw::c_int, + fClustered: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManUnrollDup(p: *mut Gia_Man_t, vLimit: *mut Vec_Int_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManUnrollAbs(p: *mut Gia_Man_t, nFrames: ::std::os::raw::c_int) -> *mut Vec_Ptr_t; +} +extern "C" { + pub fn Gia_ManUnrollStart( + pAig: *mut Gia_Man_t, + pPars: *mut Gia_ParFra_t, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn Gia_ManUnrollAdd( + pMan: *mut ::std::os::raw::c_void, + fMax: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn Gia_ManUnrollStop(pMan: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn Gia_ManUnrollLastLit(pMan: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFraSetDefaultParams(p: *mut Gia_ParFra_t); +} +extern "C" { + pub fn Gia_ManFrames(pAig: *mut Gia_Man_t, pPars: *mut Gia_ParFra_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManFramesInitSpecial( + pAig: *mut Gia_Man_t, + nFrames: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManFront(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManFrontTest(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPerformFx( + p: *mut Gia_Man_t, + nNewNodesMax: ::std::os::raw::c_int, + LitCountMax: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManHashAlloc(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManHashStart(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManHashStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManHashXorReal( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashMuxReal( + p: *mut Gia_Man_t, + iLitC: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + iLit0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashAnd( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashOr( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashXor( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashMux( + p: *mut Gia_Man_t, + iCtrl: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData0: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashMaj( + p: *mut Gia_Man_t, + iData0: ::std::os::raw::c_int, + iData1: ::std::os::raw::c_int, + iData2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashAndTry( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManRehash(p: *mut Gia_Man_t, fAddStrash: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManHashProfile(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManHashLookupInt( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashLookup( + p: *mut Gia_Man_t, + p0: *mut Gia_Obj_t, + p1: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashAndMulti(p: *mut Gia_Man_t, vLits: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashAndMulti2(p: *mut Gia_Man_t, vLits: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHashDualMiter(p: *mut Gia_Man_t, vOuts: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManPrintMappingStats(p: *mut Gia_Man_t, pDumpFile: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_ManPrintPackingStats(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPrintLutStats(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManLutFaninCount(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLutSizeMax(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLutNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLutLevel( + p: *mut Gia_Man_t, + ppLevels: *mut *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLutParams( + p: *mut Gia_Man_t, + pnCurLuts: *mut ::std::os::raw::c_int, + pnCurEdges: *mut ::std::os::raw::c_int, + pnCurLevels: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManSetRefsMapped(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSetLutRefs(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSetIfParsDefault(pIfPars: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn Gia_ManMappingVerify(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManTransferMapping(p: *mut Gia_Man_t, pGia: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManTransferPacking(p: *mut Gia_Man_t, pGia: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManTransferTiming(p: *mut Gia_Man_t, pGia: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPerformMapping( + p: *mut Gia_Man_t, + pIfPars: *mut ::std::os::raw::c_void, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPerformSopBalance( + p: *mut Gia_Man_t, + nCutNum: ::std::os::raw::c_int, + nRelaxRatio: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPerformDsdBalance( + p: *mut Gia_Man_t, + nLutSize: ::std::os::raw::c_int, + nCutNum: ::std::os::raw::c_int, + nRelaxRatio: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupHashMapping(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Jf_ManSetDefaultPars(pPars: *mut Jf_Par_t); +} +extern "C" { + pub fn Jf_ManPerformMapping(pGia: *mut Gia_Man_t, pPars: *mut Jf_Par_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Jf_ManDeriveCnf(p: *mut Gia_Man_t, fCnfObjIds: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManIsoCanonicize( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManIsoReduce( + p: *mut Gia_Man_t, + pvPosEquivs: *mut *mut Vec_Ptr_t, + pvPiPerms: *mut *mut Vec_Ptr_t, + fEstimate: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManIsoReduce2( + p: *mut Gia_Man_t, + pvPosEquivs: *mut *mut Vec_Ptr_t, + pvPiPerms: *mut *mut Vec_Ptr_t, + fEstimate: ::std::os::raw::c_int, + fBetterQual: ::std::os::raw::c_int, + fDualOut: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Lf_ManSetDefaultPars(pPars: *mut Jf_Par_t); +} +extern "C" { + pub fn Lf_ManPerformMapping(pGia: *mut Gia_Man_t, pPars: *mut Jf_Par_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPerformLfMapping( + p: *mut Gia_Man_t, + pPars: *mut Jf_Par_t, + fNormalized: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTestDistance(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSolveProblem(pGia: *mut Gia_Man_t, pPars: *mut Emb_Par_t); +} +extern "C" { + pub fn Gia_ManStart(nObjsMax: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManStopP(p: *mut *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManMemory(p: *mut Gia_Man_t) -> f64; +} +extern "C" { + pub fn Gia_ManPrintStats(p: *mut Gia_Man_t, pPars: *mut Gps_Par_t); +} +extern "C" { + pub fn Gia_ManPrintStatsShort(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPrintMiterStatus(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPrintStatsMiter(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManSetRegNum(p: *mut Gia_Man_t, nRegs: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManReportImprovement(p: *mut Gia_Man_t, pNew: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPrintNpnClasses(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDumpVerilog( + p: *mut Gia_Man_t, + pFileName: *mut ::std::os::raw::c_char, + vObjs: *mut Vec_Int_t, + fVerBufs: ::std::os::raw::c_int, + fInter: ::std::os::raw::c_int, + fInterComb: ::std::os::raw::c_int, + fAssign: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManDumpVerilogNand(p: *mut Gia_Man_t, pFileName: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_MmFixedStart( + nEntrySize: ::std::os::raw::c_int, + nEntriesMax: ::std::os::raw::c_int, + ) -> *mut Gia_MmFixed_t; +} +extern "C" { + pub fn Gia_MmFixedStop(p: *mut Gia_MmFixed_t, fVerbose: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_MmFixedEntryFetch(p: *mut Gia_MmFixed_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Gia_MmFixedEntryRecycle(p: *mut Gia_MmFixed_t, pEntry: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_MmFixedRestart(p: *mut Gia_MmFixed_t); +} +extern "C" { + pub fn Gia_MmFixedReadMemUsage(p: *mut Gia_MmFixed_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_MmFixedReadMaxEntriesUsed(p: *mut Gia_MmFixed_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_MmFlexStart() -> *mut Gia_MmFlex_t; +} +extern "C" { + pub fn Gia_MmFlexStop(p: *mut Gia_MmFlex_t, fVerbose: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_MmFlexEntryFetch( + p: *mut Gia_MmFlex_t, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Gia_MmFlexRestart(p: *mut Gia_MmFlex_t); +} +extern "C" { + pub fn Gia_MmFlexReadMemUsage(p: *mut Gia_MmFlex_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_MmStepStart(nSteps: ::std::os::raw::c_int) -> *mut Gia_MmStep_t; +} +extern "C" { + pub fn Gia_MmStepStop(p: *mut Gia_MmStep_t, fVerbose: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_MmStepEntryFetch( + p: *mut Gia_MmStep_t, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Gia_MmStepEntryRecycle( + p: *mut Gia_MmStep_t, + pEntry: *mut ::std::os::raw::c_char, + nBytes: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_MmStepReadMemUsage(p: *mut Gia_MmStep_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Mf_ManSetDefaultPars(pPars: *mut Jf_Par_t); +} +extern "C" { + pub fn Mf_ManPerformMapping(pGia: *mut Gia_Man_t, pPars: *mut Jf_Par_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Mf_ManGenerateCnf( + pGia: *mut Gia_Man_t, + nLutSize: ::std::os::raw::c_int, + fCnfObjIds: ::std::os::raw::c_int, + fAddOrCla: ::std::os::raw::c_int, + fMapping: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn Gia_ManReadMiniAig( + pFileName: *mut ::std::os::raw::c_char, + fGiaSimple: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManWriteMiniAig(pGia: *mut Gia_Man_t, pFileName: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_ManReadMiniLut(pFileName: *mut ::std::os::raw::c_char) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManWriteMiniLut(pGia: *mut Gia_Man_t, pFileName: *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn Gia_ManCountFraction( + p: *mut Gia_Man_t, + vSimI: *mut Vec_Wrd_t, + vSupp: *mut Vec_Int_t, + Thresh: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + pCare: *mut ::std::os::raw::c_int, + ) -> *mut word; +} +extern "C" { + pub fn Gia_ManCollectSuppNew( + p: *mut Gia_Man_t, + iOut: ::std::os::raw::c_int, + nOuts: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCountMuxXor( + p: *mut Gia_Man_t, + pnMuxes: *mut ::std::os::raw::c_int, + pnXors: *mut ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManPrintMuxStats(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManDupMuxes(p: *mut Gia_Man_t, Limit: ::std::os::raw::c_int) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupNoMuxes(p: *mut Gia_Man_t, fSkipBufs: ::std::os::raw::c_int) + -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_SatVerifyPattern( + p: *mut Gia_Man_t, + pRoot: *mut Gia_Obj_t, + vCex: *mut Vec_Int_t, + vVisit: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManRetimeForward( + p: *mut Gia_Man_t, + nMaxIters: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Sat_ManTest( + pGia: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + nConfsMax: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManSeqMarkUsed(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCombMarkUsed(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCleanup(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManCleanupOutputs( + p: *mut Gia_Man_t, + nOutputs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManSeqCleanup(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManSeqStructSweep( + p: *mut Gia_Man_t, + fConst: ::std::os::raw::c_int, + fEquiv: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManShow( + pMan: *mut Gia_Man_t, + vBold: *mut Vec_Int_t, + fAdders: ::std::os::raw::c_int, + fFadds: ::std::os::raw::c_int, + fPath: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManMapShrink4( + p: *mut Gia_Man_t, + fKeepLevel: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManMapShrink6( + p: *mut Gia_Man_t, + nFanoutMax: ::std::os::raw::c_int, + fKeepLevel: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManExtractWindow( + p: *mut Gia_Man_t, + LevelMax: ::std::os::raw::c_int, + nTimeWindow: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPerformSopBalanceWin( + p: *mut Gia_Man_t, + LevelMax: ::std::os::raw::c_int, + nTimeWindow: ::std::os::raw::c_int, + nCutNum: ::std::os::raw::c_int, + nRelaxRatio: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManPerformDsdBalanceWin( + p: *mut Gia_Man_t, + LevelMax: ::std::os::raw::c_int, + nTimeWindow: ::std::os::raw::c_int, + nLutSize: ::std::os::raw::c_int, + nCutNum: ::std::os::raw::c_int, + nRelaxRatio: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_SortFloats( + pArray: *mut f32, + pPerm: *mut ::std::os::raw::c_int, + nSize: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManSimSetDefaultParams(p: *mut Gia_ParSim_t); +} +extern "C" { + pub fn Gia_ManSimSimulate( + pAig: *mut Gia_Man_t, + pPars: *mut Gia_ParSim_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SimDataExt( + p: *mut Gia_ManSim_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_uint; +} +extern "C" { + pub fn Gia_SimDataCiExt( + p: *mut Gia_ManSim_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_uint; +} +extern "C" { + pub fn Gia_SimDataCoExt( + p: *mut Gia_ManSim_t, + i: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_uint; +} +extern "C" { + pub fn Gia_ManSimInfoInit(p: *mut Gia_ManSim_t); +} +extern "C" { + pub fn Gia_ManSimInfoTransfer(p: *mut Gia_ManSim_t); +} +extern "C" { + pub fn Gia_ManSimulateRound(p: *mut Gia_ManSim_t); +} +extern "C" { + pub fn Gia_ManBuiltInSimStart( + p: *mut Gia_Man_t, + nWords: ::std::os::raw::c_int, + nObjs: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManBuiltInSimCheckOver( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManBuiltInSimCheckEqual( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManBuiltInSimResimulateCone( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManBuiltInSimResimulate(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManBuiltInSimAddPat( + p: *mut Gia_Man_t, + vPat: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManIncrSimStart( + p: *mut Gia_Man_t, + nWords: ::std::os::raw::c_int, + nObjs: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManIncrSimSet(p: *mut Gia_Man_t, vObjLits: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManIncrSimCheckOver( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManIncrSimCheckEqual( + p: *mut Gia_Man_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManSimPatSim(p: *mut Gia_Man_t) -> *mut Vec_Wrd_t; +} +extern "C" { + pub fn Gia_ManSimPatSimOut( + pGia: *mut Gia_Man_t, + vSimsPi: *mut Vec_Wrd_t, + fOuts: ::std::os::raw::c_int, + ) -> *mut Vec_Wrd_t; +} +extern "C" { + pub fn Gia_ManSim2ArrayOne(vSimsPi: *mut Vec_Wrd_t, vRes: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManSim2Array(vSims: *mut Vec_Ptr_t) -> *mut Vec_Wec_t; +} +extern "C" { + pub fn Gia_ManArray2SimOne(vRes: *mut Vec_Int_t) -> *mut Vec_Wrd_t; +} +extern "C" { + pub fn Gia_ManArray2Sim(vRes: *mut Vec_Wec_t) -> *mut Vec_Ptr_t; +} +extern "C" { + pub fn Gia_ManPtrWrdDumpBin( + pFileName: *mut ::std::os::raw::c_char, + p: *mut Vec_Ptr_t, + fVerbose: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManPtrWrdReadBin( + pFileName: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Ptr_t; +} +extern "C" { + pub fn Gia_ManComputeRange(p: *mut Gia_Man_t) -> *mut Vec_Str_t; +} +extern "C" { + pub fn Gia_ManDelayTraceLut(p: *mut Gia_Man_t) -> f32; +} +extern "C" { + pub fn Gia_ManDelayTraceLutPrint(p: *mut Gia_Man_t, fVerbose: ::std::os::raw::c_int) -> f32; +} +extern "C" { + pub fn Gia_ManSpeedup( + p: *mut Gia_Man_t, + Percentage: ::std::os::raw::c_int, + Degree: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVeryVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManComputeOneWinStart( + p: *mut Gia_Man_t, + nAnds: ::std::os::raw::c_int, + fReverse: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManComputeOneWin( + p: *mut Gia_Man_t, + iPivot: ::std::os::raw::c_int, + pvRoots: *mut *mut Vec_Int_t, + pvNodes: *mut *mut Vec_Int_t, + pvLeaves: *mut *mut Vec_Int_t, + pvAnds: *mut *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManStgPrint( + pFile: *mut FILE, + vLines: *mut Vec_Int_t, + nIns: ::std::os::raw::c_int, + nOuts: ::std::os::raw::c_int, + nStates: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_ManStgRead( + pFileName: *mut ::std::os::raw::c_char, + kHot: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_ManMin_t_ { + _unused: [u8; 0], +} +pub type Gia_ManMin_t = Gia_ManMin_t_; +extern "C" { + pub fn Gia_ManSuppStart(pGia: *mut Gia_Man_t) -> *mut Gia_ManMin_t; +} +extern "C" { + pub fn Gia_ManSuppStop(p: *mut Gia_ManMin_t); +} +extern "C" { + pub fn Gia_ManSupportAnd( + p: *mut Gia_ManMin_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Gia_Man2Min_t_ { + _unused: [u8; 0], +} +pub type Gia_Man2Min_t = Gia_Man2Min_t_; +extern "C" { + pub fn Gia_Man2SuppStart(pGia: *mut Gia_Man_t) -> *mut Gia_Man2Min_t; +} +extern "C" { + pub fn Gia_Man2SuppStop(p: *mut Gia_Man2Min_t); +} +extern "C" { + pub fn Gia_Man2SupportAnd( + p: *mut Gia_Man2Min_t, + iLit0: ::std::os::raw::c_int, + iLit1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManFraigSweepSimple( + p: *mut Gia_Man_t, + pPars: *mut ::std::os::raw::c_void, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManSweepWithBoxes( + p: *mut Gia_Man_t, + pParsC: *mut ::std::os::raw::c_void, + pParsS: *mut ::std::os::raw::c_void, + fConst: ::std::os::raw::c_int, + fEquiv: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + fVerbEquivs: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManCheckIntegrityWithBoxes(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_SweeperStart(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_SweeperStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_SweeperIsRunning(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperPrintStats(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_SweeperSetConflictLimit(p: *mut Gia_Man_t, nConfMax: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_SweeperSetRuntimeLimit(p: *mut Gia_Man_t, nSeconds: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_SweeperGetCex(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_SweeperProbeCreate( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperProbeDelete( + p: *mut Gia_Man_t, + ProbeId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperProbeUpdate( + p: *mut Gia_Man_t, + ProbeId: ::std::os::raw::c_int, + iLitNew: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperProbeLit( + p: *mut Gia_Man_t, + ProbeId: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperCollectValidProbeIds(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_SweeperCondPop(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperCondPush(p: *mut Gia_Man_t, ProbeId: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_SweeperCondVector(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_SweeperCondCheckUnsat(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperCheckEquiv( + p: *mut Gia_Man_t, + ProbeId1: ::std::os::raw::c_int, + ProbeId2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperExtractUserLogic( + p: *mut Gia_Man_t, + vProbeIds: *mut Vec_Int_t, + vInNames: *mut Vec_Ptr_t, + vOutNames: *mut Vec_Ptr_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_SweeperLogicDump( + p: *mut Gia_Man_t, + vProbeIds: *mut Vec_Int_t, + fDumpConds: ::std::os::raw::c_int, + pFileName: *mut ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn Gia_SweeperCleanup( + p: *mut Gia_Man_t, + pCommLime: *mut ::std::os::raw::c_char, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_SweeperGraft( + pDst: *mut Gia_Man_t, + vProbes: *mut Vec_Int_t, + pSrc: *mut Gia_Man_t, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_SweeperFraig( + p: *mut Gia_Man_t, + vProbeIds: *mut Vec_Int_t, + pCommLime: *mut ::std::os::raw::c_char, + nWords: ::std::os::raw::c_int, + nConfs: ::std::os::raw::c_int, + fVerify: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_SweeperRun( + p: *mut Gia_Man_t, + vProbeIds: *mut Vec_Int_t, + pCommLime: *mut ::std::os::raw::c_char, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManEvaluateSwitching(p: *mut Gia_Man_t) -> f32; +} +extern "C" { + pub fn Gia_ManComputeSwitching( + p: *mut Gia_Man_t, + nFrames: ::std::os::raw::c_int, + nPref: ::std::os::raw::c_int, + fProbOne: ::std::os::raw::c_int, + ) -> f32; +} +extern "C" { + pub fn Gia_ManComputeSwitchProbs( + pGia: *mut Gia_Man_t, + nFrames: ::std::os::raw::c_int, + nPref: ::std::os::raw::c_int, + fProbOne: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManPrintOutputProb(p: *mut Gia_Man_t) -> *mut Vec_Flt_t; +} +extern "C" { + pub fn Gia_ManBoxNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManRegBoxNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManNonRegBoxNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManBlackBoxNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManBoxCiNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManBoxCoNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManClockDomainNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManIsSeqWithBoxes(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManIsNormalized(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManOrderWithBoxes(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManDupNormalize( + p: *mut Gia_Man_t, + fHashMapping: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupUnnormalize(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupUnshuffleInputs(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManLevelWithBoxes(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLutLevelWithBoxes(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManUpdateTimMan( + p: *mut Gia_Man_t, + vBoxPres: *mut Vec_Int_t, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn Gia_ManUpdateTimMan2( + p: *mut Gia_Man_t, + vBoxesLeft: *mut Vec_Int_t, + nTermsDiff: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn Gia_ManUpdateExtraAig( + pTime: *mut ::std::os::raw::c_void, + pAig: *mut Gia_Man_t, + vBoxPres: *mut Vec_Int_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManUpdateExtraAig2( + pTime: *mut ::std::os::raw::c_void, + pAig: *mut Gia_Man_t, + vBoxesLeft: *mut Vec_Int_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManDupCollapse( + p: *mut Gia_Man_t, + pBoxes: *mut Gia_Man_t, + vBoxPres: *mut Vec_Int_t, + fSeq: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManVerifyWithBoxes( + pGia: *mut Gia_Man_t, + nBTLimit: ::std::os::raw::c_int, + nTimeLim: ::std::os::raw::c_int, + fSeq: ::std::os::raw::c_int, + fDumpFiles: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + pFileSpec: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_LutComputeTruth6( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + vTruths: *mut Vec_Wrd_t, + ) -> word; +} +extern "C" { + pub fn Gia_ObjComputeTruthTable6Lut( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + vTemp: *mut Vec_Wrd_t, + ) -> word; +} +extern "C" { + pub fn Gia_ObjComputeTruthTable6( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + vSupp: *mut Vec_Int_t, + vTruths: *mut Vec_Wrd_t, + ) -> word; +} +extern "C" { + pub fn Gia_ObjComputeTruth6Cis( + p: *mut Gia_Man_t, + iLit: ::std::os::raw::c_int, + vSupp: *mut Vec_Int_t, + vTemp: *mut Vec_Wrd_t, + ) -> word; +} +extern "C" { + pub fn Gia_ObjCollectInternal(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ObjComputeTruthTable(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t) -> *mut word; +} +extern "C" { + pub fn Gia_ObjComputeTruthTableStart(p: *mut Gia_Man_t, nVarsMax: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ObjComputeTruthTableStop(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ObjComputeTruthTableCut( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + vLeaves: *mut Vec_Int_t, + ) -> *mut word; +} +extern "C" { + pub fn Gia_ManReduceConst( + pAig: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManRandom(fReset: ::std::os::raw::c_int) -> ::std::os::raw::c_uint; +} +extern "C" { + pub fn Gia_ManRandomW(fReset: ::std::os::raw::c_int) -> word; +} +extern "C" { + pub fn Gia_ManRandomInfo( + vInfo: *mut Vec_Ptr_t, + iInputStart: ::std::os::raw::c_int, + iWordStart: ::std::os::raw::c_int, + iWordStop: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Gia_TimeStamp() -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Gia_FileNameGenericAppend( + pBase: *mut ::std::os::raw::c_char, + pSuffix: *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn Gia_ManIncrementTravId(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanMark01(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSetMark0(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanMark0(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCheckMark0(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSetMark1(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanMark1(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCheckMark1(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanValue(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanLevels(p: *mut Gia_Man_t, Size: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManCleanTruth(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManFillValue(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ObjSetPhase(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManSetPhase(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSetPhasePattern(p: *mut Gia_Man_t, vCiValues: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManSetPhase1(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCleanPhase(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCheckCoPhase(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLevelNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManLevelRNum(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManGetCiLevels(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManSetLevels(p: *mut Gia_Man_t, vCiLevels: *mut Vec_Int_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManReverseLevel(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManRequiredLevel(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCreateValueRefs(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCreateRefs(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCreateMuxRefs(p: *mut Gia_Man_t) -> *mut ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCrossCut( + p: *mut Gia_Man_t, + fReverse: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCollectPoIds(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ObjIsMuxType(pNode: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ObjRecognizeExor( + pObj: *mut Gia_Obj_t, + ppFan0: *mut *mut Gia_Obj_t, + ppFan1: *mut *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ObjRecognizeMux( + pNode: *mut Gia_Obj_t, + ppNodeT: *mut *mut Gia_Obj_t, + ppNodeE: *mut *mut Gia_Obj_t, + ) -> *mut Gia_Obj_t; +} +extern "C" { + pub fn Gia_ObjRecognizeMuxLits( + p: *mut Gia_Man_t, + pNode: *mut Gia_Obj_t, + iLitT: *mut ::std::os::raw::c_int, + iLitE: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_NodeMffcSize(p: *mut Gia_Man_t, pNode: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_NodeMffcSizeMark(p: *mut Gia_Man_t, pNode: *mut Gia_Obj_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_NodeMffcSizeSupp( + p: *mut Gia_Man_t, + pNode: *mut Gia_Obj_t, + vSupp: *mut Vec_Int_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_NodeMffcMapping(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManHasDangling(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManMarkDangling(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManGetDangling(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ObjPrint(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManPrint(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManPrintCo(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManPrintCone( + p: *mut Gia_Man_t, + pObj: *mut Gia_Obj_t, + pLeaves: *mut ::std::os::raw::c_int, + nLeaves: ::std::os::raw::c_int, + vNodes: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManPrintConeMulti( + p: *mut Gia_Man_t, + vObjs: *mut Vec_Int_t, + vLeaves: *mut Vec_Int_t, + vNodes: *mut Vec_Int_t, + ); +} +extern "C" { + pub fn Gia_ManPrintCone2(p: *mut Gia_Man_t, pObj: *mut Gia_Obj_t); +} +extern "C" { + pub fn Gia_ManInvertConstraints(pAig: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManInvertPos(pAig: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManCompare(p1: *mut Gia_Man_t, p2: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManMarkFanoutDrivers(p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManSwapPos(p: *mut Gia_Man_t, i: ::std::os::raw::c_int); +} +extern "C" { + pub fn Gia_ManSaveValue(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManLoadValue(p: *mut Gia_Man_t, vValues: *mut Vec_Int_t); +} +extern "C" { + pub fn Gia_ManFirstFanouts(p: *mut Gia_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManCheckSuppOverlap( + p: *mut Gia_Man_t, + iNode1: ::std::os::raw::c_int, + iNode2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCountPisWithFanout(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManCountPosWithNonZeroDrivers(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Gia_ManUpdateCopy(vCopy: *mut Vec_Int_t, p: *mut Gia_Man_t); +} +extern "C" { + pub fn Gia_ManComputeDistance( + p: *mut Gia_Man_t, + iObj: ::std::os::raw::c_int, + vObjs: *mut Vec_Int_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Gia_ManTtopt( + p: *mut Gia_Man_t, + nIns: ::std::os::raw::c_int, + nOuts: ::std::os::raw::c_int, + nRounds: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTtoptCare( + p: *mut Gia_Man_t, + nIns: ::std::os::raw::c_int, + nOuts: ::std::os::raw::c_int, + nRounds: ::std::os::raw::c_int, + pFileName: *mut ::std::os::raw::c_char, + nRarity: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransductionBdd( + pGia: *mut Gia_Man_t, + nType: ::std::os::raw::c_int, + fMspf: ::std::os::raw::c_int, + nRandom: ::std::os::raw::c_int, + nSortType: ::std::os::raw::c_int, + nPiShuffle: ::std::os::raw::c_int, + nParameter: ::std::os::raw::c_int, + fLevel: ::std::os::raw::c_int, + pExdc: *mut Gia_Man_t, + fNewLine: ::std::os::raw::c_int, + nVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Gia_ManTransductionTt( + pGia: *mut Gia_Man_t, + nType: ::std::os::raw::c_int, + fMspf: ::std::os::raw::c_int, + nRandom: ::std::os::raw::c_int, + nSortType: ::std::os::raw::c_int, + nPiShuffle: ::std::os::raw::c_int, + nParameter: ::std::os::raw::c_int, + fLevel: ::std::os::raw::c_int, + pExdc: *mut Gia_Man_t, + fNewLine: ::std::os::raw::c_int, + nVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Tas_Man_t_ { + _unused: [u8; 0], +} +pub type Tas_Man_t = Tas_Man_t_; +extern "C" { + pub fn Tas_ManAlloc(pAig: *mut Gia_Man_t, nBTLimit: ::std::os::raw::c_int) -> *mut Tas_Man_t; +} +extern "C" { + pub fn Tas_ManStop(p: *mut Tas_Man_t); +} +extern "C" { + pub fn Tas_ReadModel(p: *mut Tas_Man_t) -> *mut Vec_Int_t; +} +extern "C" { + pub fn Tas_ManSatPrintStats(p: *mut Tas_Man_t); +} +extern "C" { + pub fn Tas_ManSolve( + p: *mut Tas_Man_t, + pObj: *mut Gia_Obj_t, + pObj2: *mut Gia_Obj_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Tas_ManSolveArray(p: *mut Tas_Man_t, vObjs: *mut Vec_Ptr_t) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Bnd_Man_t_ { + _unused: [u8; 0], +} +pub type Bnd_Man_t = Bnd_Man_t_; +extern "C" { + pub fn Bnd_ManStart( + pSpec: *mut Gia_Man_t, + pImpl: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Bnd_Man_t; +} +extern "C" { + pub fn Bnd_ManStop(); +} +extern "C" { + pub fn Bnd_ManGetNInternal() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Bnd_ManGetNExtra() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Bnd_ManMap( + iLit: ::std::os::raw::c_int, + id: ::std::os::raw::c_int, + spec: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Bnd_ManMerge( + id1: ::std::os::raw::c_int, + id2: ::std::os::raw::c_int, + phaseDiff: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn Bnd_ManFinalizeMappings(); +} +extern "C" { + pub fn Bnd_ManPrintMappings(); +} +extern "C" { + pub fn Bnd_ManStackGias(pSpec: *mut Gia_Man_t, pImpl: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManCheckCoMerged(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Bnd_ManCheckBound( + p: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Bnd_ManFindBound(p: *mut Gia_Man_t, pImpl: *mut Gia_Man_t); +} +extern "C" { + pub fn Bnd_ManGenSpecOut(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManGenImplOut(p: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManGenPatched( + pOut: *mut Gia_Man_t, + pSpec: *mut Gia_Man_t, + pPatch: *mut Gia_Man_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManGenPatched1(pOut: *mut Gia_Man_t, pSpec: *mut Gia_Man_t) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManGenPatched2( + pImpl: *mut Gia_Man_t, + pPatch: *mut Gia_Man_t, + fSkiptStrash: ::std::os::raw::c_int, + fVerbose: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Bnd_ManSetEqOut(eq: ::std::os::raw::c_int); +} +extern "C" { + pub fn Bnd_ManSetEqRes(eq: ::std::os::raw::c_int); +} +extern "C" { + pub fn Bnd_ManPrintStats(); +} +extern "C" { + pub fn Bnd_ManCutBoundary( + p: *mut Gia_Man_t, + vEI: *mut Vec_Int_t, + vEO: *mut Vec_Int_t, + vEI_phase: *mut Vec_Bit_t, + vEO_phase: *mut Vec_Bit_t, + ) -> *mut Gia_Man_t; +} +pub type Cec_ParSat_t = Cec_ParSat_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParSat_t_ { + pub SolverType: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub nSatVarMax: ::std::os::raw::c_int, + pub nCallsRecycle: ::std::os::raw::c_int, + pub fNonChrono: ::std::os::raw::c_int, + pub fPolarFlip: ::std::os::raw::c_int, + pub fCheckMiter: ::std::os::raw::c_int, + pub fLearnCls: ::std::os::raw::c_int, + pub fSaveCexes: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParSat_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Cec_ParSat_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParSat_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).SolverType) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(SolverType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSatVarMax) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(nSatVarMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCallsRecycle) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(nCallsRecycle) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fNonChrono) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fNonChrono) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fPolarFlip) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fPolarFlip) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCheckMiter) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fCheckMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fLearnCls) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fLearnCls) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSaveCexes) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fSaveCexes) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSat_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Cec_ParSim_t = Cec_ParSim_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParSim_t_ { + pub nWords: ::std::os::raw::c_int, + pub nFrames: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nNonRefines: ::std::os::raw::c_int, + pub TimeLimit: ::std::os::raw::c_int, + pub fDualOut: ::std::os::raw::c_int, + pub fCheckMiter: ::std::os::raw::c_int, + pub fSeqSimulate: ::std::os::raw::c_int, + pub fLatchCorr: ::std::os::raw::c_int, + pub fConstCorr: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParSim_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Cec_ParSim_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParSim_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFrames) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(nFrames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nNonRefines) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(nNonRefines) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(TimeLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDualOut) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fDualOut) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCheckMiter) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fCheckMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSeqSimulate) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fSeqSimulate) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fLatchCorr) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fLatchCorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fConstCorr) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fConstCorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSim_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Cec_ParSmf_t = Cec_ParSmf_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParSmf_t_ { + pub nWords: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nFrames: ::std::os::raw::c_int, + pub nNonRefines: ::std::os::raw::c_int, + pub nMinOutputs: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub TimeLimit: ::std::os::raw::c_int, + pub fDualOut: ::std::os::raw::c_int, + pub fCheckMiter: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParSmf_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Cec_ParSmf_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParSmf_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFrames) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nFrames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nNonRefines) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nNonRefines) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nMinOutputs) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nMinOutputs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(TimeLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDualOut) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(fDualOut) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCheckMiter) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(fCheckMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSmf_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Cec_ParFra_t = Cec_ParFra_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParFra_t_ { + pub jType: ::std::os::raw::c_int, + pub nWords: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nItersMax: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub nBTLimitPo: ::std::os::raw::c_int, + pub TimeLimit: ::std::os::raw::c_int, + pub nLevelMax: ::std::os::raw::c_int, + pub nDepthMax: ::std::os::raw::c_int, + pub nCallsRecycle: ::std::os::raw::c_int, + pub nSatVarMax: ::std::os::raw::c_int, + pub nGenIters: ::std::os::raw::c_int, + pub fRewriting: ::std::os::raw::c_int, + pub fCheckMiter: ::std::os::raw::c_int, + pub fDualOut: ::std::os::raw::c_int, + pub fColorDiff: ::std::os::raw::c_int, + pub fSatSweeping: ::std::os::raw::c_int, + pub fRunCSat: ::std::os::raw::c_int, + pub fUseCones: ::std::os::raw::c_int, + pub fUseOrigIds: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub iOutFail: ::std::os::raw::c_int, + pub fBMiterInfo: ::std::os::raw::c_int, + pub nPO: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParFra_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 100usize, + concat!("Size of: ", stringify!(Cec_ParFra_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParFra_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).jType) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(jType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nItersMax) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nItersMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimitPo) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nBTLimitPo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(TimeLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLevelMax) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nLevelMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nDepthMax) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nDepthMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nCallsRecycle) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nCallsRecycle) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nSatVarMax) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nSatVarMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nGenIters) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nGenIters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fRewriting) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fRewriting) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fCheckMiter) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fCheckMiter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fDualOut) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fDualOut) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fColorDiff) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fColorDiff) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSatSweeping) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fSatSweeping) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fRunCSat) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fRunCSat) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseCones) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fUseCones) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseOrigIds) as usize - ptr as usize }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fUseOrigIds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 84usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iOutFail) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(iOutFail) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fBMiterInfo) as usize - ptr as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(fBMiterInfo) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nPO) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParFra_t_), + "::", + stringify!(nPO) + ) + ); +} +pub type Cec_ParCec_t = Cec_ParCec_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParCec_t_ { + pub nBTLimit: ::std::os::raw::c_int, + pub TimeLimit: ::std::os::raw::c_int, + pub fUseSmartCnf: ::std::os::raw::c_int, + pub fRewriting: ::std::os::raw::c_int, + pub fNaive: ::std::os::raw::c_int, + pub fSilent: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub iOutFail: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParCec_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 36usize, + concat!("Size of: ", stringify!(Cec_ParCec_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParCec_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TimeLimit) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(TimeLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseSmartCnf) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fUseSmartCnf) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fRewriting) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fRewriting) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fNaive) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fNaive) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fSilent) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fSilent) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).iOutFail) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCec_t_), + "::", + stringify!(iOutFail) + ) + ); +} +pub type Cec_ParCor_t = Cec_ParCor_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParCor_t_ { + pub nWords: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nFrames: ::std::os::raw::c_int, + pub nPrefix: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub nProcs: ::std::os::raw::c_int, + pub nPartSize: ::std::os::raw::c_int, + pub nLevelMax: ::std::os::raw::c_int, + pub nStepsMax: ::std::os::raw::c_int, + pub nLimitMax: ::std::os::raw::c_int, + pub fLatchCorr: ::std::os::raw::c_int, + pub fConstCorr: ::std::os::raw::c_int, + pub fUseRings: ::std::os::raw::c_int, + pub fMakeChoices: ::std::os::raw::c_int, + pub fUseCSat: ::std::os::raw::c_int, + pub fUseSmartCnf: ::std::os::raw::c_int, + pub fStopWhenGone: ::std::os::raw::c_int, + pub fVerboseFlops: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, + pub pData: *mut ::std::os::raw::c_void, + pub pFunc: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_Cec_ParCor_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(Cec_ParCor_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Cec_ParCor_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFrames) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nFrames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nPrefix) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nPrefix) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nProcs) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nProcs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nPartSize) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nPartSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLevelMax) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nLevelMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nStepsMax) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nStepsMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLimitMax) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(nLimitMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fLatchCorr) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fLatchCorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fConstCorr) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fConstCorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseRings) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fUseRings) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fMakeChoices) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fMakeChoices) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseCSat) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fUseCSat) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseSmartCnf) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fUseSmartCnf) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fStopWhenGone) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fStopWhenGone) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerboseFlops) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fVerboseFlops) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(fVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pData) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(pData) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pFunc) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParCor_t_), + "::", + stringify!(pFunc) + ) + ); +} +pub type Cec_ParChc_t = Cec_ParChc_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParChc_t_ { + pub nWords: ::std::os::raw::c_int, + pub nRounds: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub fUseRings: ::std::os::raw::c_int, + pub fUseCSat: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParChc_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 28usize, + concat!("Size of: ", stringify!(Cec_ParChc_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParChc_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nWords) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(nWords) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nRounds) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(nRounds) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseRings) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(fUseRings) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseCSat) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(fUseCSat) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParChc_t_), + "::", + stringify!(fVerbose) + ) + ); +} +pub type Cec_ParSeq_t = Cec_ParSeq_t_; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Cec_ParSeq_t_ { + pub fUseLcorr: ::std::os::raw::c_int, + pub fUseScorr: ::std::os::raw::c_int, + pub nBTLimit: ::std::os::raw::c_int, + pub nFrames: ::std::os::raw::c_int, + pub nLevelMax: ::std::os::raw::c_int, + pub fConsts: ::std::os::raw::c_int, + pub fEquivs: ::std::os::raw::c_int, + pub fUseMiniSat: ::std::os::raw::c_int, + pub nMinDomSize: ::std::os::raw::c_int, + pub fVeryVerbose: ::std::os::raw::c_int, + pub fVerbose: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Cec_ParSeq_t_() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 44usize, + concat!("Size of: ", stringify!(Cec_ParSeq_t_)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Cec_ParSeq_t_)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseLcorr) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fUseLcorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseScorr) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fUseScorr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nBTLimit) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(nBTLimit) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nFrames) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(nFrames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nLevelMax) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(nLevelMax) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fConsts) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fConsts) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fEquivs) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fEquivs) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fUseMiniSat) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fUseMiniSat) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).nMinDomSize) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(nMinDomSize) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVeryVerbose) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fVeryVerbose) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).fVerbose) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Cec_ParSeq_t_), + "::", + stringify!(fVerbose) + ) + ); +} +extern "C" { + pub fn Cec_ManVerify(p: *mut Gia_Man_t, pPars: *mut Cec_ParCec_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManVerifyTwo( + p0: *mut Gia_Man_t, + p1: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManVerifyTwoInv( + p0: *mut Gia_Man_t, + p1: *mut Gia_Man_t, + fVerbose: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManVerifySimple(p: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManChoiceComputation( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParChc_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Cec_ManLSCorrespondenceClasses( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParCor_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManLSCorrespondence( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParCor_t, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Cec_ManSatSetDefaultParams(p: *mut Cec_ParSat_t); +} +extern "C" { + pub fn Cec_ManSimSetDefaultParams(p: *mut Cec_ParSim_t); +} +extern "C" { + pub fn Cec_ManSmfSetDefaultParams(p: *mut Cec_ParSmf_t); +} +extern "C" { + pub fn Cec_ManFraSetDefaultParams(p: *mut Cec_ParFra_t); +} +extern "C" { + pub fn Cec_ManCecSetDefaultParams(p: *mut Cec_ParCec_t); +} +extern "C" { + pub fn Cec_ManCorSetDefaultParams(p: *mut Cec_ParCor_t); +} +extern "C" { + pub fn Cec_ManChcSetDefaultParams(p: *mut Cec_ParChc_t); +} +extern "C" { + pub fn Cec_ManSatSweeping( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParFra_t, + fSilent: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Cec_ManSatSolving( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParSat_t, + f0Proved: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} +extern "C" { + pub fn Cec_ManSimulation(pAig: *mut Gia_Man_t, pPars: *mut Cec_ParSim_t); +} +extern "C" { + pub fn Cec_ManSeqResimulateCounter( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParSim_t, + pCex: *mut Abc_Cex_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManSeqSemiformal( + pAig: *mut Gia_Man_t, + pPars: *mut Cec_ParSmf_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_ManCheckNonTrivialCands(pAig: *mut Gia_Man_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_SeqReadMinDomSize(p: *mut Cec_ParSeq_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_SeqReadVerbose(p: *mut Cec_ParSeq_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec_SeqSynthesisSetDefaultParams(pPars: *mut Cec_ParSeq_t); +} +extern "C" { + pub fn Cec_SequentialSynthesisPart( + p: *mut Gia_Man_t, + pPars: *mut Cec_ParSeq_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn Cec4_ManSetParams(pPars: *mut Cec_ParFra_t); +} +extern "C" { + pub fn Cec5_ManSimulateTest( + p: *mut Gia_Man_t, + pPars: *mut Cec_ParFra_t, + fCbs: ::std::os::raw::c_int, + approxLim: ::std::os::raw::c_int, + subBatchSz: ::std::os::raw::c_int, + adaRecycle: ::std::os::raw::c_int, + ) -> *mut Gia_Man_t; +} diff --git a/abc-sys/src/generated/bindings.sha256 b/abc-sys/src/generated/bindings.sha256 new file mode 100644 index 0000000..3c200f2 --- /dev/null +++ b/abc-sys/src/generated/bindings.sha256 @@ -0,0 +1,18 @@ +SHA2-256(abc/src/aig/gia/gia.h)= 2cee796123ee68b450d3029b8405083b16776a5fd1c590b32fd78978fb5ab6d1 +SHA2-256(abc/src/misc/util/abc_global.h)= 948da3ebe06d2a1a849bc5d1dfca9ebd9ef51f9138ffeda85be06dd84f6ed901 +SHA2-256(abc/src/misc/util/abc_namespaces.h)= 49d311b6585a8a4306f796c9351bfaa3709abe9bc72fb067feb4fdb2e111ebdf +SHA2-256(abc/src/misc/util/utilCex.h)= eaa281e5454a02069451596708195994b219edf4d18a3a95d546a7d6f6970e2b +SHA2-256(abc/src/misc/vec/vec.h)= 2baeaf8ec333691979083f121f033d69ac0a1d7012d345366cf4e50e3562a168 +SHA2-256(abc/src/misc/vec/vecAtt.h)= 1bd98e7a83173ad68d38c8350d3992945a42cbcde5e331c43fbabfa3ecd88e0d +SHA2-256(abc/src/misc/vec/vecBit.h)= 3541cee9e086edbc3823e37490ef7b04851456d1123b3faa712d57b64d2bb023 +SHA2-256(abc/src/misc/vec/vecFlt.h)= 144fe3fd7c17d5cbfcae03cb88560fb8e0e07c8eee77a46814afac5f55dc6b03 +SHA2-256(abc/src/misc/vec/vecInt.h)= 48b70abca020f0037775f9310b396631dff627a68b416e177d692a0a1d8ff158 +SHA2-256(abc/src/misc/vec/vecMem.h)= aa8f258960662968ff7b0925d4cda10df2259daca6784fa581b34bff326e08de +SHA2-256(abc/src/misc/vec/vecPtr.h)= 53413f98b54c0dc3f734f2df28c0d49447b182e5a4e4d5beefca1b4aed3d334c +SHA2-256(abc/src/misc/vec/vecStr.h)= 7780e21a690b1f115fda5afb3e28ccbe46e5307de20bb4b9fac4b47de98af840 +SHA2-256(abc/src/misc/vec/vecVec.h)= eaf0c09457689468144f4e60ea30ebeb73a366ffab36005522218504ada2c84c +SHA2-256(abc/src/misc/vec/vecWec.h)= 0020092d244e456c13b56e8ae52e94b53cfba2422f805627f9ebd3e8a25cec54 +SHA2-256(abc/src/misc/vec/vecWrd.h)= 16a47ab71a8e0578f819f416d19672b3e2976e8b214ef2cd0b81b548464d124e +SHA2-256(abc/src/proof/cec/cec.h)= bd2440bd4656c6df16927c9232cae7ba82943bab319b5c239a1efa871d2dec4c +SHA2-256(src/bindings.h)= d684d11c885f3f5c41f38bb6b3a0ef1ea11034ee10e167e0d8bc289caf1bba47 +SHA2-256(codegen.sh)= 74176df39a93a4c37035d58393e8015f0e7c0578383f34f7ab1369f1233fc419 diff --git a/abc-sys/src/lib.rs b/abc-sys/src/lib.rs new file mode 100644 index 0000000..6d13177 --- /dev/null +++ b/abc-sys/src/lib.rs @@ -0,0 +1,63 @@ +#[allow(non_snake_case)] +#[allow(non_camel_case_types)] +#[allow(non_upper_case_globals)] +#[allow(clippy::all)] +mod bindings { + use libc::FILE; + include!("generated/bindings.rs"); +} + +pub use bindings::*; + +#[cfg(test)] +mod tests { + #[test] + fn test_gia_man() { + use super::bindings as abc; + unsafe { + let gia = abc::Gia_ManStart(100); + + let ci_1 = abc::Gia_ManAppendCi(gia); + let ci_2 = abc::Gia_ManAppendCi(gia); + + let obj_2 = abc::Gia_ManAppendAnd(gia, ci_1, ci_2); + + abc::Gia_ManAppendCo(gia, obj_2); + + // let mut params: Cec_ParFra_t = std::mem::zeroed(); + // Cec4_ManSetParams(&mut params); + // params.fVerbose = 0; + + // let new_gia = Cec5_ManSimulateTest(gia, &mut params, 1, 600, 1, 500); + // Gia_ManStop(gia); + // gia = new_gia; + + abc::Gia_ManStop(gia); + } + } + + #[test] + fn test_fraig_y() { + use super::bindings as abc; + unsafe { + let mut gia = abc::Gia_ManStart(100); + + let ci_1 = abc::Gia_ManAppendCi(gia); + let ci_2 = abc::Gia_ManAppendCi(gia); + + let obj_2 = abc::Gia_ManAppendAnd(gia, ci_1, ci_2); + + abc::Gia_ManAppendCo(gia, obj_2); + + let mut params: abc::Cec_ParFra_t = std::mem::zeroed(); + abc::Cec4_ManSetParams(&mut params); + params.fVerbose = 0; + + let new_gia = abc::Cec5_ManSimulateTest(gia, &mut params, 1, 600, 1, 500); + abc::Gia_ManStop(gia); + gia = new_gia; + + abc::Gia_ManStop(gia); + } + } +}