├── tests ├── config.nims └── test1.nim ├── z3.nimble ├── README.md └── src ├── z3.nim └── z3 └── z3_api.nim /tests/config.nims: -------------------------------------------------------------------------------- 1 | switch("path", "$projectDir/../src") -------------------------------------------------------------------------------- /z3.nimble: -------------------------------------------------------------------------------- 1 | # Package 2 | 3 | version = "0.1.3" 4 | author = "Ico Doornekamp" 5 | description = "Nim Z3 theorem prover bindings" 6 | license = "MIT" 7 | srcDir = "src" 8 | installExt = @["nim"] 9 | 10 | # Dependencies 11 | 12 | requires "nim >= 0.19.0" 13 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | # Nim Z3 3 | 4 | > "_Z3 is a cat with a funny hat_" 5 | > -TheLemonMan 6 | 7 | NimZ3 is an early stage Nim binding for the [Z3 theorem prover](https://github.com/Z3Prover/z3) 8 | 9 | 10 | ## Documentation 11 | 12 | * [Module documentation](http://htmlpreview.github.io/?https://github.com/zevv/nimz3/blob/master/src/z3.html) 13 | * [Examples](https://github.com/zevv/nimz3/blob/master/tests/test1.nim) 14 | 15 | 16 | ## Status 17 | 18 | This is still a work in progress and a lot of Z3 is still missing, but the most 19 | important basics are available: 20 | 21 | * bool, bit vector, int and float types 22 | * solving 23 | * optimization 24 | * simplification 25 | 26 | The API uses template magic to hide Z3 contexts and allows normal Nim syntax for defining Z3 model assertions. 27 | 28 | 29 | ## Example 30 | 31 | ```nim 32 | z3: 33 | let x = Int("x") 34 | let y = Int("y") 35 | let z = Int("z") 36 | let s = Solver() 37 | s.assert 3 * x + 2 * y - z == 1 38 | s.assert 2 * x - 2 * y + 4 * z == -2 39 | s.assert x * -1 + y / 2 - z == 0 40 | s.check_model: 41 | echo model 42 | ``` 43 | 44 | Answer: 45 | 46 | ``` 47 | z -> (- 2) 48 | y -> (- 2) 49 | x -> 1 50 | ``` 51 | 52 | More examples are available in the tests directory, run with `nimble test`. 53 | 54 | 55 | ## More Z3 info 56 | 57 | Some helpful documents and tutorials about Z3: 58 | 59 | * [Z3 - guide](https://rise4fun.com/z3/tutorialcontent/guide) 60 | * [Programming Z3](https://theory.stanford.edu/~nikolaj/programmingz3.html) 61 | 62 | 63 | ## Open questions 64 | 65 | Things I'm not sure how to solve yet. Any input appreciated: 66 | 67 | * Should there be distinct types for signed and unsigned bit vectors? This would 68 | make it easier to implement operators for things like Z3_mk_bvXXX_no_overflow() 69 | 70 | * What is a good way to create Z3 consts? The current method of doing 71 | `let x = Int "x"` is redundant and prone to mistakes. Is it better to create 72 | some kind of declaration template instead? 73 | -------------------------------------------------------------------------------- /tests/test1.nim: -------------------------------------------------------------------------------- 1 | import unittest 2 | import z3 3 | 4 | 5 | suite "z3": 6 | 7 | test "demorgan": 8 | z3: 9 | # De Morgan: !(!(x && y) <-> (!x || !y)) 10 | let x = Bool("x") 11 | let y = Bool("y") 12 | let exp = not (not (x and y )) <-> ((not x) or (not y)) 13 | echo exp 14 | let s = Solver() 15 | s.assert (x and y) or (not x and y) 16 | if s.check() == Z3_L_TRUE: 17 | echo s.get_model() 18 | 19 | test "tie or shirt?": 20 | z3: 21 | let tie = Bool("tie") 22 | let shirt = Bool("shirt") 23 | let s = Solver() 24 | s.assert (not tie) or shirt 25 | s.assert (not tie) or not(shirt) 26 | if s.check() == Z3_L_TRUE: 27 | echo s.get_model() 28 | 29 | 30 | test "math school problem": 31 | z3: 32 | let x = Int("x") 33 | let y = Int("y") 34 | let z = Int("z") 35 | let s = Solver() 36 | s.assert 3 * x + 2 * y - z == 1 37 | s.assert 2 * x - 2 * y + 4 * z == -2 38 | s.assert x * -1 + y / 2 - z == 0 39 | echo s 40 | if s.check() == Z3_L_TRUE: 41 | echo s.get_model() 42 | 43 | test "XKCD restaurant order": 44 | 45 | z3: 46 | let a = Int("a") 47 | let b = Int("b") 48 | let c = Int("c") 49 | let d = Int("d") 50 | let e = Int("e") 51 | let f = Int("f") 52 | 53 | let s = Solver() 54 | s.assert a*215 + b*275 + c*335 + d*355 + e*420 + f*580 == 1505 55 | s.assert a<100 and b<100 and c<100 and d<100 and e<100 and f<100 56 | s.assert a>=0 and b>=0 and c>=0 and d>=0 and e>=0 and f>=0 57 | if s.check() == Z3_L_TRUE: 58 | echo s.get_model() 59 | 60 | test "sudoku": 61 | 62 | # "Extreme" sudoku: http://www.sudokuwiki.org/Weekly_Sudoku.asp?puz=28 63 | 64 | let · = 0 65 | let sudoku = [ 66 | [ ·, ·, ·, ·, ·, 8, 9, 4, · ], 67 | [ 9, ·, ·, ·, ·, 6, 1, ·, · ], 68 | [ ·, 7, ·, ·, 4, ·, ·, ·, · ], 69 | [ 2, ·, ·, 6, 1, ·, ·, ·, · ], 70 | [ ·, ·, ·, ·, ·, ·, 2, ·, · ], 71 | [ ·, 8, 9, ·, ·, 2, ·, ·, · ], 72 | [ ·, ·, ·, ·, 6, ·, ·, ·, 5 ], 73 | [ ·, ·, ·, ·, ·, ·, ·, 3, · ], 74 | [ 8, ·, ·, ·, ·, 1, 6, ·, · ], 75 | ] 76 | 77 | z3: 78 | let s = Solver() 79 | var cs: array[9, array[9, Z3_ast_int]] 80 | 81 | # Create sudoku cells 82 | 83 | for y, row in sudoku.pairs(): 84 | for x, v in row.pairs(): 85 | let c = Int($x & "," & $y) 86 | cs[y][x] = c 87 | if v != 0: 88 | s.assert c == v 89 | else: 90 | s.assert c >= 1 and c <= 9 91 | 92 | # Each row and col contains each digit only once 93 | 94 | for row in cs: 95 | s.assert distinc row 96 | 97 | for y in 0..8: 98 | var col: seq[Z3_ast_int] 99 | for x in 0..8: 100 | col.add cs[x][y] 101 | s.assert distinc(col) 102 | 103 | # Each 3x3 square contains each digit only once 104 | 105 | for x in [0, 3, 6]: 106 | for y in [0, 3, 6]: 107 | var sq: seq[Z3_ast_int] 108 | for dx in 0..2: 109 | for dy in 0..2: 110 | sq.add cs[x+dx][y+dy] 111 | s.assert distinc sq 112 | 113 | # Get model and print solution 114 | 115 | s.check_model: 116 | for row in cs: 117 | for c in row: 118 | stdout.write $eval(c) & " " 119 | stdout.write "\n" 120 | 121 | test "scopes": 122 | z3: 123 | let x = Int "x" 124 | let y = Int "y" 125 | let s = Solver() 126 | s.push: 127 | s.assert -x + y == 10 128 | s.assert x + y * 2 == 20 129 | echo s.check 130 | s.push: 131 | s.assert 3 * x + y == 10 132 | s.assert 2 * x + 2 * y == 21 133 | echo s.check 134 | 135 | test "simplify": 136 | z3: 137 | let x = Int "x" 138 | let y = Int "y" 139 | let e = x + 2 * y + 3 * x - y - y 140 | echo e 141 | echo simplify e 142 | 143 | test "floating point": 144 | z3: 145 | let x = Float "x" 146 | let y = Float "y" 147 | let s = Solver() 148 | s.assert x * 2.0 == y 149 | s.assert x == 15.0 150 | if s.check() == Z3_L_TRUE: 151 | let model = s.get_model() 152 | echo eval(x) 153 | 154 | test "forall": 155 | z3: 156 | let s = Solver() 157 | let x = Int "x" 158 | let y = Int "y" 159 | s.assert y == 1 160 | s.assert forall([x], x * y == x) 161 | if s.check() == Z3_L_TRUE: 162 | echo s.get_model() 163 | 164 | test "exists": 165 | z3: 166 | let s = Solver() 167 | let x = Int "x" 168 | let y = Int "y" 169 | s.assert y == 20 170 | s.assert exists([x], x * y == 180) 171 | if s.check() == Z3_L_TRUE: 172 | echo s.get_model() 173 | 174 | test "planetary/epicyclic gear system": 175 | # Find the gear tooth count for a planetary gear system with a 176 | # ratio of 1:12 177 | 178 | z3: 179 | let R = Int("R") # ring teeth 180 | let S = Int("S") # sun teeth 181 | let P = Int("P") # planet teeth 182 | 183 | let Tr = Int("Tr") # ring turns 184 | let Ts = Int("Ts") # sun turns 185 | let Ty = Int("Ty") # carrier turns 186 | 187 | let s = Solver() 188 | 189 | s.assert Ts == 12 # Sun speed 190 | s.assert Tr == 0 # Ring speed 191 | s.assert Ty == 1 # Y-carrier speed 192 | 193 | s.assert R >= 10 # Don't make gears too small 194 | s.assert P >= 10 195 | s.assert S >= 10 196 | 197 | # Planetary gears constraints 198 | s.assert (R + S) * Ty == R * Tr + Ts * S 199 | s.assert R == 2 * P + S 200 | 201 | s.check_model: 202 | echo model 203 | 204 | when false: # This test fails with never versions of Z3. 205 | 206 | test "optimize": 207 | # Pablo buys popsicles for his friends. The store sells single popsicles 208 | # for $1 each, 3-popsicle boxes for $2, and 5-popsicle boxes for $3. What 209 | # is the greatest number of popsicles that Pablo can buy with $8? 210 | z3: 211 | let s = Optimizer() 212 | let a = Int "a" 213 | let n = Int "n" 214 | let p1 = Int "p1" 215 | let p3 = Int "p3" 216 | let p5 = Int "p5" 217 | s.assert a == p1 * 1 + p3 * 2 + p5 * 3 218 | s.assert n == p1 * 1 + p3 * 3 + p5 * 5 219 | s.assert p1 >= 0 and p3 >= 0 and p5 >= 0 220 | s.assert a == 8 221 | s.maximize n 222 | echo s 223 | if s.check() == Z3_L_TRUE: 224 | echo s.get_model() 225 | 226 | # vim: ft=nim 227 | 228 | -------------------------------------------------------------------------------- /src/z3.nim: -------------------------------------------------------------------------------- 1 | 2 | ## # Z3 3 | ## 4 | ## This library provides a Nim binding to the Z3 theorem prover. 5 | ## 6 | ## ## Z3 context 7 | ## 8 | ## Almost all Z3 C API functions take a Z3_context argument. This Nim binding 9 | ## uses a block level template called `z3` which creates a Z3_context and injects 10 | ## this into the template scope. All other Z3 functions are implemented using 11 | ## templates who use this implicitly available context variable. 12 | ## 13 | ## ## Z3 AST types 14 | ## 15 | ## The Z3 C API uses one single type `Z3_ast` for all possible node sorts. 16 | ## Internally, the `Z3_ast` has a type (called "sorts") which can be boolean, 17 | ## integer, real, etc. Z3 provides a lot of functions for building AST trees, 18 | ## but it requires the programmer to keep track of the implicit type to make 19 | ## sure the right functions are called for the right nodes. For example, to add 20 | ## two numbers of the sort `Z3_INT_KIND`, the `Z3_mk_add` function is used, but 21 | ## to add to numbers of the sort `Z3_BV_SORT` the user needs to call 22 | ## `Z3_mk_bvadd`. 23 | ## 24 | ## This Nim binding allows the usage of native operators, so the user can simply 25 | ## use the `+` operator instead of `Z3_mk_add`. For this reason, Nim needs to keep 26 | ## track of the underlying Z3 node sort for each Z3 ast node. Other API's like the 27 | ## Python binding do this by wrapping each `Z3_ast` node in an external object, and 28 | ## provide methods applying to these objects. This Nim binding uses distinct 29 | ## types instead: for each Z3 node sort, there is a matching Nim type provided of 30 | ## the type `distinct Z3_ast`. 31 | ## 32 | ## * `Z3_ast_bool`: A node of the kind `Z3_BOOL_SORT`. To create a Z3 AST node 33 | ## of this type use the `Bool()` template 34 | ## 35 | ## * `Z3_ast_bv`: A node of the kind `Z3_BV_SORT`. To create a Z3 AST node of 36 | ## this type use the `Bv(length)` template, where the `length` 37 | ## argument indicates the bitvector size 38 | ## 39 | ## * `Z3_ast_int`: A node of the kind `Z3_INT_SORT`. To create a Z3 AST node 40 | ## of this type use the `Int()` template 41 | ## 42 | ## * `Z3_ast_fpa`: A node of the kind `Z3_FLOATING_POINT_SORT`. To create a Z3 43 | ## AST node of this type use the `Float()` template. At this 44 | ## time floating point nodes are all of the `double` sort. 45 | ## 46 | ## ## Operators 47 | ## 48 | ## All Nim operators working on Z3 AST nodes are defined for the appropriate 49 | ## Z3_ast types only, and make sure they return the proper type as well. This 50 | ## allows the programmer to freely mix and match Z3 operators, and the Nim 51 | ## compiler will make sure all types are validated at compile time, instead of 52 | ## relying on run-time exceptions generated by the Z3 library. For example: 53 | ## 54 | ## .. code-block::nim 55 | ## z3: 56 | ## let s = Solver() 57 | ## 58 | ## let i1 = Int("i1") 59 | ## let i2 = Int("i2") 60 | ## let b = Bool("b") 61 | ## let f1 = Float("f1") 62 | ## 63 | ## s.assert b == (i1 * i2 == 25) and (i1 + i2) == 10 64 | ## s.assert b and (f1 == 3.0) 65 | ## 66 | ## s.check_model: 67 | ## echo model 68 | ## 69 | ## More examples are available in the nimble tests at https://github.com/zevv/nimz3/blob/master/tests/test1.nim 70 | ## 71 | ## For more info on Z3 check the official guide at https://rise4fun.com/z3/tutorialcontent/guide 72 | 73 | import z3/z3_api 74 | from strutils import parseFloat 75 | from math import pow 76 | 77 | export Z3_ast 78 | export Z3_lbool 79 | 80 | type 81 | 82 | Z3Exception* = object of Exception 83 | ## Exception thrown from the Z3 error handler. The exception message is 84 | ## generated by the Z3 library and states the reason for the error 85 | 86 | Z3_ast_ptr = ptr Z3_ast 87 | 88 | Z3_ast_bool* = distinct Z3_ast 89 | Z3_ast_bv* = distinct Z3_ast 90 | Z3_ast_int* = distinct Z3_ast 91 | Z3_ast_fpa* = distinct Z3_ast 92 | 93 | Z3_ast_any = Z3_ast | Z3_ast_bool | Z3_ast_bv | Z3_ast_int | Z3_ast_fpa 94 | 95 | 96 | # Z3 type constructors 97 | 98 | template mk_var(name: string, ty: Z3_sort): Z3_ast = 99 | let sym = Z3_mk_string_symbol(ctx, name) 100 | Z3_mk_const(ctx, sym, ty) 101 | 102 | template Bool*(name: string): Z3_ast_bool = 103 | ## Create a Z3 constant of the type Bool. 104 | mk_var(name, Z3_mk_bool_sort(ctx)).Z3_ast_bool 105 | 106 | template Int*(name: string): Z3_ast_int = 107 | ## Create a Z3 constant of the type Int. 108 | mk_var(name, Z3_mk_int_sort(ctx)).Z3_ast_int 109 | 110 | template Bv*(name: string, sz: int): Z3_ast_bv = 111 | ## Create a Z3 constant of the type BV with a size of `sz` bits. 112 | mk_var(name, Z3_mk_bv_sort(ctx, sz.cuint)).Z3_ast_bv 113 | 114 | template Float*(name: string): Z3_ast_fpa = 115 | ## Create a Z3 constant of the type Float. 116 | mkvar(name, Z3_mk_fpa_sort_double(ctx)).Z3_ast_fpa 117 | 118 | 119 | 120 | # Stringifications 121 | 122 | template `$`*(v: Z3_ast_any): string = 123 | ## Create a string representation of the Z3 ast node 124 | {.push hint[ConvFromXtoItselfNotNeeded]: off.} 125 | $Z3_ast_to_string(ctx, v.Z3_ast) 126 | 127 | template `$`*(m: Z3_model): string = 128 | ## Create a string representation of the Z3 model 129 | $Z3_model_to_string(ctx, m) 130 | 131 | template `$`*(m: Z3_solver): string = 132 | ## Create a string representation of the Z3 solver 133 | $Z3_solver_to_string(ctx, m) 134 | 135 | template `$`*(m: Z3_optimize): string = 136 | ## Create a string representation of the Z3 optimizer 137 | $Z3_optimize_to_string(ctx, m) 138 | 139 | template `$`*(m: Z3_pattern): string = 140 | ## Create a string representation of the Z3 pattern 141 | $Z3_pattern_to_string(ctx, m) 142 | 143 | 144 | 145 | # Misc 146 | 147 | template simplify*(s: Z3_ast_any): Z3_ast = 148 | Z3_simplify(ctx, s.Z3_ast) 149 | 150 | 151 | # 152 | # Solver interface 153 | # 154 | 155 | template Solver*(): Z3_solver = 156 | ## Create a Z3 solver context 157 | Z3_mk_solver(ctx) 158 | 159 | template assert*(s: Z3_solver, e: Z3_ast_any) = 160 | ## Assert hard constraint to the solver context. 161 | Z3_solver_assert(ctx, s, e.Z3_ast) 162 | 163 | template check*(s: Z3_solver): Z3_lbool = 164 | ## Check whether the assertions in a given solver are consistent or not. 165 | Z3_solver_check(ctx, s) 166 | 167 | template get_model*(s: Z3_Solver): Z3_model = 168 | ## Retrieve the model for the last solver.check 169 | Z3_solver_get_model(ctx, s) 170 | 171 | template push*(s: Z3_Solver, code: untyped) = 172 | ## Create a backtracking point. This is to be used as a block scope template, 173 | ## so the state pop will by automatically generated when leaving the scope: 174 | ## 175 | ## .. code-block::nim 176 | ## z3: 177 | ## let s = Solver() 178 | ## s.assert ... 179 | ## s.push: 180 | ## s.assert .. 181 | ## s.check 182 | ## s.assert ... 183 | ## 184 | Z3_solver_push(ctx, s) 185 | block: 186 | code 187 | Z3_solver_pop(ctx, s, 1) 188 | 189 | template check_model*(s: Z3_solver, code: untyped) = 190 | ## A helper block-scope template that combines `check` and `get_model`. If 191 | ## the solver was consistent the model is available in the variable `model` 192 | ## inside the block scope. If the solver failed a Z3Exception will be thrown. 193 | if Z3_solver_check(ctx, s) == Z3_L_TRUE: 194 | let model {.inject.} = Z3_solver_get_model(ctx, s) 195 | code 196 | else: 197 | raise newException(Z3Exception, "UNSAT") 198 | 199 | 200 | # 201 | # Optimizer interface 202 | # 203 | 204 | template Optimizer*(): Z3_optimize = 205 | ## Create a Z3 optimizer 206 | Z3_mk_optimize(ctx) 207 | 208 | template minimize*(o: Z3_optimize, e: Z3_ast_any) = 209 | ## Add a minimization constraint. 210 | echo Z3_optimize_minimize(ctx, o, e.Z3_ast) 211 | 212 | template maximize*(o: Z3_optimize, e: Z3_ast_any) = 213 | ## Add a maximization constraint. 214 | echo Z3_optimize_maximize(ctx, o, e.Z3_ast) 215 | 216 | template assert*(o: Z3_optimize, e: Z3_ast_any) = 217 | ## Assert hard constraint to the optimization context. 218 | Z3_optimize_assert(ctx, o, e.Z3_ast) 219 | 220 | template check*(s: Z3_optimize): Z3_lbool = 221 | ## Check whether the assertions in a given optimize are consistent or not. 222 | Z3_optimize_check(ctx, s) 223 | 224 | template get_model*(s: Z3_optimize): Z3_model = 225 | ## Retrieve the model for the last optimize.check 226 | Z3_optimize_get_model(ctx, s) 227 | 228 | template check_model*(s: Z3_optimize, code: untyped) = 229 | if Z3_optimize_check(ctx, s) == Z3_L_TRUE: 230 | let model {.inject.} = Z3_optimize_get_model(ctx, s) 231 | code 232 | else: 233 | raise newException(Z3Exception, "UNSAT") 234 | 235 | # 236 | # Misc 237 | # 238 | 239 | template eval*(v: Z3_ast_any): Z3_ast = 240 | var r: Z3_ast 241 | if not Z3_model_eval(ctx, model, v.Z3_ast, true, addr r): 242 | raise newException(Z3Exception, "eval failed") 243 | r 244 | 245 | template evalInt*(v: Z3_ast_any): int = 246 | var c: cint 247 | if not Z3_get_numeral_int(ctx, eval(v), addr c): 248 | raise newException(Z3Exception, "evalInt: can not convert") 249 | c 250 | 251 | template evalFloat*(v: Z3_ast_any): float = 252 | let ss = splitWhitespace $Z3_get_numeral_string(ctx, eval(v)) 253 | ss[0].parseFloat * pow(2.0, ss[1].parseFloat) 254 | 255 | proc on_err(ctx: Z3_context, e: Z3_error_code) {.nimcall.} = 256 | let msg = $Z3_get_error_msg(ctx, e) 257 | raise newException(Z3Exception, msg) 258 | 259 | 260 | template z3*(code: untyped) = 261 | 262 | ## The main Z3 context template. This template creates an implicit 263 | ## Z3_context which all other API functions need. Z3 errors are 264 | ## caught and throw a Z3Exception 265 | 266 | block: 267 | 268 | let cfg = Z3_mk_config() 269 | Z3_set_param_value(cfg, "model", "true"); 270 | let ctx {.inject used.} = Z3_mk_context(cfg) 271 | let fpa_rm {.inject used.} = Z3_mk_fpa_round_nearest_ties_to_even(ctx) 272 | Z3_del_config(cfg) 273 | Z3_set_error_handler(ctx, on_err) 274 | 275 | block: 276 | code 277 | 278 | Z3_del_context(ctx) 279 | 280 | 281 | # 282 | # Operators working on Z3_ast nodes 283 | # 284 | 285 | # Helpers to create a Nim value to the appropriate Z3_ast sort 286 | 287 | template checkKind(ctx: Z3_context, kinds: set[Z3_sort_kind], typ: string) = 288 | let kind = Z3_get_sort_kind(ctx, sort) 289 | if kind notin kinds: 290 | raise newException(Z3Exception, "Can not create a " & $kind & " from a " & typ) 291 | 292 | proc to_Z3_ast(ctx: Z3_context, v: Z3_ast_any): Z3_ast = 293 | v.Z3_ast 294 | 295 | proc to_Z3_ast(ctx: Z3_context, v: bool, sort: Z3_sort = nil): Z3_ast = 296 | checkKind ctx, {Z3_BOOL_SORT}, "integer" 297 | if v: Z3_mk_true(ctx) else: Z3_mk_false(ctx) 298 | 299 | proc to_Z3_ast(ctx: Z3_context, v: SomeInteger, sort: Z3_sort = nil): Z3_ast = 300 | checkKind ctx, {Z3_INT_SORT,Z3_BV_SORT}, "integer" 301 | Z3_mk_int64(ctx, v.clonglong, sort) 302 | 303 | proc to_Z3_ast(ctx: Z3_context, v: float, sort: Z3_sort = nil): Z3_ast = 304 | checkKind ctx, {Z3_FLOATING_POINT_SORT}, "integer" 305 | Z3_mk_fpa_numeral_double(ctx, v.cdouble, sort) 306 | 307 | proc to_Z3_ast(ctx: Z3_context, v: string, sort: Z3_sort = nil): Z3_ast = 308 | Z3_mk_numeral(ctx, v, sort) 309 | 310 | 311 | # Generator helpers: these allow calling of binop type functions (like 312 | # Z3_mk_xor) or vararg-type functions (like Z3_mk_add) through the same 313 | # signature. 314 | 315 | template helper_bin(ctx: Z3_context, fn: untyped, v1, v2: Z3_ast_any): Z3_ast = 316 | fn(ctx, v1.Z3_ast, v2.Z3_ast) 317 | 318 | template helper_var(ctx: Z3_context, fn: untyped, v1, v2: Z3_ast_any): Z3_ast = 319 | let vs = [v1.Z3_ast, v2.Z3_ast] 320 | fn(ctx, 2, unsafeAddr vs[0]) 321 | 322 | template helper_bin_fpa(ctx: Z3_context, fn: untyped, v1, v2: Z3_ast_any): Z3_ast = 323 | fn(ctx, fpa_rm, v1.Z3_ast, v2.Z3_ast) 324 | 325 | template helper_uni(ctx: Z3_context, fn: untyped, v: Z3_ast): Z3_ast = 326 | fn(ctx, v) 327 | 328 | template helper_uni_fpa(ctx: Z3_context, fn: untyped, v: Z3_ast_any): Z3_ast = 329 | fn(ctx, fpa_rm, v.Z3_ast) 330 | 331 | 332 | # Generator templates for an unary operators 333 | 334 | template uniop(name: untyped, Tin, Tout: untyped, fn: untyped, helper: untyped) = 335 | 336 | template name*(a: Tin): Tout = 337 | helper(ctx, fn, a.Z3_ast).Tout 338 | 339 | 340 | # Generator templates for an binary operators 341 | 342 | template binop(name: untyped, Tin, Tout: untyped, fn: untyped, helper: untyped) = 343 | 344 | template name*(a1, a2: Tin): Tout = 345 | helper(ctx, fn, a1, a2).Tout 346 | 347 | template name*[T](a1: Tin, a2: T): Tout = 348 | helper(ctx, fn, a1, to_Z3_ast(ctx, a2, Z3_get_sort(ctx, a1.Z3_ast)).Tin).Tout 349 | 350 | template name*[T](a1: T, a2: Tin): Tout = 351 | helper(ctx, fn, to_Z3_ast(ctx, a1, Z3_get_sort(ctx, a2.Z3_ast)).Tin, a2).Tout 352 | 353 | 354 | # Boolean operators and functions 355 | 356 | binop(`and`, Z3_ast_bool, Z3_ast_bool, Z3_mk_and, helper_var) 357 | binop(`or`, Z3_ast_bool, Z3_ast_bool, Z3_mk_or, helper_var) 358 | binop(`xor`, Z3_ast_bool, Z3_ast_bool, Z3_mk_xor, helper_bin) 359 | binop(`==`, Z3_ast_bool, Z3_ast_bool, Z3_mk_eq, helper_bin) 360 | binop(`<->`, Z3_ast_bool, Z3_ast_bool, Z3_mk_iff, helper_bin) 361 | binop(`->`, Z3_ast_bool, Z3_ast_bool, Z3_mk_implies, helper_bin) 362 | uniop(`not`, Z3_ast_bool, Z3_ast_bool, Z3_mk_not, helper_uni) 363 | 364 | # Bit vector operators and functions 365 | 366 | binop(`and`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvand, helper_bin) 367 | binop(`mod`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvsmod, helper_bin) 368 | binop(`nor`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvnor, helper_bin) 369 | binop(`or`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvor , helper_bin) 370 | binop(`shl`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvshl, helper_bin) 371 | binop(`shr`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvlshr, helper_bin) 372 | binop(`xnor`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvxnor, helper_bin) 373 | binop(`xor`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvxor, helper_bin) 374 | binop(`>=`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvsge, helper_bin) 375 | binop(`>`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvsgt, helper_bin) 376 | binop(`<=`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvsle, helper_bin) 377 | binop(`<`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvslt, helper_bin) 378 | binop(`>=%`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvuge, helper_bin) 379 | binop(`>%`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvugt, helper_bin) 380 | binop(`<=%`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvule, helper_bin) 381 | binop(`<%`, Z3_ast_bv, Z3_ast_bool, Z3_mk_bvult, helper_bin) 382 | binop(`==`, Z3_ast_bv, Z3_ast_bool, Z3_mk_eq, helper_bin) 383 | binop(`<->`, Z3_ast_bv, Z3_ast_bool, Z3_mk_iff, helper_bin) 384 | binop(`+`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvadd, helper_bin) 385 | binop(`*`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvmul, helper_bin) 386 | binop(`/`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvsdiv, helper_bin) 387 | binop(`-`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvsub, helper_bin) 388 | binop(`/%`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvudiv, helper_bin) 389 | binop(`&`, Z3_ast_bv, Z3_ast_bv, Z3_mk_concat, helper_bin) 390 | uniop(`not`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvnot, helper_uni) 391 | uniop(`-`, Z3_ast_bv, Z3_ast_bv, Z3_mk_bvneg, helper_uni) 392 | 393 | # Integer operators and functions 394 | 395 | binop(`==`, Z3_ast_int, Z3_ast_bool, Z3_mk_eq, helper_bin) 396 | binop(`>=`, Z3_ast_int, Z3_ast_bool, Z3_mk_ge, helper_bin) 397 | binop(`>`, Z3_ast_int, Z3_ast_bool, Z3_mk_gt, helper_bin) 398 | binop(`<->`, Z3_ast_int, Z3_ast_bool, Z3_mk_iff, helper_bin) 399 | binop(`<=`, Z3_ast_int, Z3_ast_bool, Z3_mk_le, helper_bin) 400 | binop(`<`, Z3_ast_int, Z3_ast_bool, Z3_mk_lt, helper_bin) 401 | binop(`+`, Z3_ast_int, Z3_ast_int, Z3_mk_add, helper_var) 402 | binop(`/`, Z3_ast_int, Z3_ast_int, Z3_mk_div, helper_bin) 403 | binop(`*`, Z3_ast_int, Z3_ast_int, Z3_mk_mul, helper_var) 404 | binop(`-`, Z3_ast_int, Z3_ast_int, Z3_mk_sub, helper_var) 405 | uniop(`-`, Z3_ast_int, Z3_ast_int, Z3_mk_unary_minus, helper_uni) 406 | binop(`mod`, Z3_ast_int, Z3_ast_int, Z3_mk_mod, helper_bin) 407 | binop(`^`, Z3_ast_int, Z3_ast_int, Z3_mk_power, helper_bin) 408 | 409 | # Floating point operators and functions 410 | 411 | binop(`==`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_eq, helper_bin) 412 | binop(`>=`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_fpa_geq, helper_bin) 413 | binop(`>`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_fpa_gt, helper_bin) 414 | binop(`<->`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_fpa_iff, helper_bin) 415 | binop(`<=`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_fpa_leq, helper_bin) 416 | binop(`<`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_fpa_lt, helper_bin) 417 | binop(`<->`, Z3_ast_fpa, Z3_ast_bool, Z3_mk_iff, helper_bin) 418 | binop(`+`, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_add, helper_bin_fpa) 419 | binop(`/`, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_div, helper_bin_fpa) 420 | binop(`*`, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_mul, helper_bin_fpa) 421 | binop(`-`, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_sub, helper_bin_fpa) 422 | uniop(abs, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_abs, helper_uni) 423 | uniop(sqrt, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_sqrt, helper_uni_fpa) 424 | uniop(`-`, Z3_ast_fpa, Z3_ast_fpa, Z3_mk_fpa_neg, helper_uni) 425 | 426 | # Miscellaneous 427 | 428 | proc vararg_helper[T](ctx: Z3_context, fn: T, vs: varargs[Z3_ast_any]): Z3_ast = 429 | fn(ctx, vs.len.cuint, Z3_ast_ptr(unsafeAddr(vs[0]))) 430 | 431 | template distinc*[T: Z3_ast_bool|Z3_ast_bv|Z3_ast_int](vs: varargs[T]): Z3_ast_bool = 432 | vararg_helper(ctx, Z3_mk_distinct, vs).Z3_ast_bool 433 | 434 | template ite*[T](v1: bool|Z3_ast_bool, v2, v3: T): T = 435 | T(Z3_mk_ite(ctx, to_Z3_ast(ctx, v1), to_Z3_ast(ctx, v2), to_Z3_ast(ctx, v3))) 436 | 437 | template exists*(vs: openarray[Z3_ast_any], body: Z3_ast_bool): Z3_ast_bool = 438 | # Create an exists formula 439 | var bound: seq[Z3_app] 440 | for v in vs: bound.add Z3_to_app(ctx, v.Z3_ast) 441 | Z3_mk_exists_const(ctx, 0, bound.len.cuint, addr(bound[0]), 0, nil, body.Z3_ast).Z3_ast_bool 442 | 443 | template ∃*(vs: openarray[Z3_ast_any], body: Z3_ast_bool): Z3_ast_bool = 444 | # Create an exists formula 445 | exists(vs, body) 446 | 447 | template forall*(vs: openarray[Z3_ast_any], body: Z3_ast_bool): Z3_ast_bool = 448 | # Create an forall formula 449 | var bound: seq[Z3_app] 450 | for v in vs: bound.add Z3_to_app(ctx, v.Z3_ast) 451 | Z3_mk_forall_const(ctx, 0, bound.len.cuint, addr(bound[0]), 0, nil, body.Z3_ast).Z3_ast_bool 452 | 453 | template ∀*(vs: openarray[Z3_ast_any], body: Z3_ast_bool): Z3_ast_bool = 454 | # Create an forall formula 455 | forall(vs, body) 456 | 457 | # vim: ft=nim 458 | 459 | -------------------------------------------------------------------------------- /src/z3/z3_api.nim: -------------------------------------------------------------------------------- 1 | {.experimental: "codeReordering".} 2 | 3 | 4 | converter enumToInt(en: Z3_lbool): int {.used.} = en.int 5 | 6 | type Z3_symbol_kind* = distinct int 7 | converter enumToInt(en: Z3_symbol_kind): int {.used.} = en.int 8 | 9 | type Z3_decl_kind* = distinct int 10 | converter enumToInt(en: Z3_decl_kind): int {.used.} = en.int 11 | 12 | type Z3_search_failure* = distinct int 13 | converter enumToInt(en: Z3_search_failure): int {.used.} = en.int 14 | 15 | type Z3_ast_print_mode* = distinct int 16 | converter enumToInt(en: Z3_ast_print_mode): int {.used.} = en.int 17 | 18 | type Z3_goal_prec* = distinct int 19 | converter enumToInt(en: Z3_goal_prec): int {.used.} = en.int 20 | 21 | type 22 | Z3_lbool* = enum 23 | Z3_L_FALSE = -1, 24 | Z3_L_UNDEF = 0, 25 | Z3_L_TRUE = 1 26 | 27 | Z3_error_code* = enum 28 | Z3_OK = 0, 29 | Z3_SORT_ERROR = 1, 30 | Z3_IOB = 2, 31 | Z3_INVALID_ARG = 3, 32 | Z3_PARSER_ERROR = 4, 33 | Z3_NO_PARSER = 5, 34 | Z3_INVALID_PATTERN = 6, 35 | Z3_MEMOUT_FAIL = 7, 36 | Z3_FILE_ACCESS_ERROR = 8, 37 | Z3_INTERNAL_FATAL = 9, 38 | Z3_INVALID_USAGE = 10, 39 | Z3_DEC_REF_ERROR = 11, 40 | Z3_EXCEPTION = 12, 41 | 42 | Z3_sort_kind* = enum 43 | Z3_UNINTERPRETED_SORT, 44 | Z3_BOOL_SORT, 45 | Z3_INT_SORT, 46 | Z3_REAL_SORT, 47 | Z3_BV_SORT, 48 | Z3_ARRAY_SORT, 49 | Z3_DATATYPE_SORT, 50 | Z3_RELATION_SORT, 51 | Z3_FINITE_DOMAIN_SORT, 52 | Z3_FLOATING_POINT_SORT, 53 | Z3_ROUNDING_MODE_SORT, 54 | Z3_UNKNOWN_SORT = 1000 55 | 56 | const 57 | libz3 = when defined(windows): "libz3.dll" else: "libz3.so" 58 | STDC_PREDEF_H* = 1 59 | STDC_IEC_559* = 1 60 | STDC_IEC_559_COMPLEX* = 1 61 | Z3_TRUE* = 1 62 | Z3_FALSE* = 0 63 | Z3_INT_SYMBOL* = 0.Z3_symbol_kind 64 | Z3_STRING_SYMBOL* = 1.Z3_symbol_kind 65 | Z3_NO_FAILURE* = 0.Z3_search_failure 66 | Z3_UNKNOWN* = 1.Z3_search_failure 67 | Z3_TIMEOUT* = 2.Z3_search_failure 68 | Z3_MEMOUT_WATERMARK* = 3.Z3_search_failure 69 | Z3_CANCELED* = 4.Z3_search_failure 70 | Z3_NUM_CONFLICTS* = 5.Z3_search_failure 71 | Z3_THEORY2* = 6.Z3_search_failure 72 | Z3_QUANTIFIERS* = 7.Z3_search_failure 73 | Z3_PRINT_SMTLIB_FULL* = 0.Z3_ast_print_mode 74 | Z3_PRINT_LOW_LEVEL* = 1.Z3_ast_print_mode 75 | Z3_PRINT_SMTLIB_COMPLIANT* = 2.Z3_ast_print_mode 76 | Z3_PRINT_SMTLIB2_COMPLIANT* = 3.Z3_ast_print_mode 77 | Z3_GOAL_PRECISE* = 0.Z3_goal_prec 78 | Z3_GOAL_UNDER* = 1.Z3_goal_prec 79 | Z3_GOAL_OVER* = 2.Z3_goal_prec 80 | Z3_GOAL_UNDER_OVER* = 3.Z3_goal_prec 81 | 82 | type 83 | Z3_symbol* = distinct pointer 84 | Z3_literals* = distinct pointer 85 | Z3_theory* = distinct pointer 86 | Z3_config* = distinct pointer 87 | Z3_context* = distinct pointer 88 | Z3_sort* = distinct pointer 89 | Z3_func_decl* = distinct pointer 90 | Z3_ast* = distinct pointer 91 | Z3_app* = distinct pointer 92 | Z3_pattern* = distinct pointer 93 | Z3_model* = distinct pointer 94 | Z3_constructor* = distinct pointer 95 | Z3_constructor_list* = distinct pointer 96 | Z3_params* = distinct pointer 97 | Z3_param_descrs* = distinct pointer 98 | Z3_goal* = distinct pointer 99 | Z3_tactic* = distinct pointer 100 | Z3_probe* = distinct pointer 101 | Z3_stats* = distinct pointer 102 | Z3_solver* = distinct pointer 103 | Z3_ast_vector* = distinct pointer 104 | Z3_ast_map* = distinct pointer 105 | Z3_apply_result* = distinct pointer 106 | Z3_func_interp* = distinct pointer 107 | Z3_func_entry* = distinct pointer 108 | Z3_fixedpoint* = distinct pointer 109 | Z3_optimize* = distinct pointer 110 | Z3_rcf_num* = distinct pointer 111 | Z3_theory_data* = distinct pointer 112 | Z3_bool* = bool 113 | Z3_string* = cstring 114 | Z3_string_ptr* = ptr Z3_string 115 | Z3_error_handler* = proc(c: Z3_context,e: Z3_error_code) {.nimcall.} 116 | Z3_reduce_eq_callback_fptr* = proc(t: Z3_theory,a: Z3_ast,b: Z3_ast,r: ptr Z3_ast): Z3_bool {.nimcall.} 117 | Z3_theory_callback_fptr* = proc(t: Z3_theory) {.nimcall.} 118 | Z3_theory_final_check_callback_fptr* = proc(a1: Z3_theory): Z3_bool {.nimcall.} 119 | Z3_theory_ast_callback_fptr* = proc(a1: Z3_theory,a2: Z3_ast) {.nimcall.} 120 | Z3_theory_ast_bool_callback_fptr* = proc(a1: Z3_theory,a2: Z3_ast,a3: Z3_bool) {.nimcall.} 121 | Z3_theory_ast_ast_callback_fptr* = proc(a1: Z3_theory,a2: Z3_ast,a3: Z3_ast) {.nimcall.} 122 | 123 | proc Z3_global_param_set*(param_id: Z3_string,param_value: Z3_string) {.importc: "Z3_global_param_set", dynlib: libz3.} 124 | proc Z3_global_param_reset_all*() {.importc: "Z3_global_param_reset_all", dynlib: libz3.} 125 | proc Z3_global_param_get*(param_id: Z3_string,param_value: Z3_string_ptr): Z3_bool {.importc: "Z3_global_param_get", dynlib: libz3.} 126 | proc Z3_mk_config*(): Z3_config {.importc: "Z3_mk_config", dynlib: libz3.} 127 | proc Z3_del_config*(c: Z3_config) {.importc: "Z3_del_config", dynlib: libz3.} 128 | proc Z3_set_param_value*(c: Z3_config,param_id: Z3_string,param_value: Z3_string) {.importc: "Z3_set_param_value", dynlib: libz3.} 129 | proc Z3_mk_context*(c: Z3_config): Z3_context {.importc: "Z3_mk_context", dynlib: libz3.} 130 | proc Z3_mk_context_rc*(c: Z3_config): Z3_context {.importc: "Z3_mk_context_rc", dynlib: libz3.} 131 | proc Z3_del_context*(c: Z3_context) {.importc: "Z3_del_context", dynlib: libz3.} 132 | proc Z3_inc_ref*(c: Z3_context,a: Z3_ast) {.importc: "Z3_inc_ref", dynlib: libz3.} 133 | proc Z3_dec_ref*(c: Z3_context,a: Z3_ast) {.importc: "Z3_dec_ref", dynlib: libz3.} 134 | proc Z3_update_param_value*(c: Z3_context,param_id: Z3_string,param_value: Z3_string) {.importc: "Z3_update_param_value", dynlib: libz3.} 135 | proc Z3_interrupt*(c: Z3_context) {.importc: "Z3_interrupt", dynlib: libz3.} 136 | proc Z3_mk_params*(c: Z3_context): Z3_params {.importc: "Z3_mk_params", dynlib: libz3.} 137 | proc Z3_params_inc_ref*(c: Z3_context,p: Z3_params) {.importc: "Z3_params_inc_ref", dynlib: libz3.} 138 | proc Z3_params_dec_ref*(c: Z3_context,p: Z3_params) {.importc: "Z3_params_dec_ref", dynlib: libz3.} 139 | proc Z3_params_set_bool*(c: Z3_context,p: Z3_params,k: Z3_symbol,v: Z3_bool) {.importc: "Z3_params_set_bool", dynlib: libz3.} 140 | proc Z3_params_set_uint*(c: Z3_context,p: Z3_params,k: Z3_symbol,v: cuint) {.importc: "Z3_params_set_uint", dynlib: libz3.} 141 | proc Z3_params_set_double*(c: Z3_context,p: Z3_params,k: Z3_symbol,v: cdouble) {.importc: "Z3_params_set_double", dynlib: libz3.} 142 | proc Z3_params_set_symbol*(c: Z3_context,p: Z3_params,k: Z3_symbol,v: Z3_symbol) {.importc: "Z3_params_set_symbol", dynlib: libz3.} 143 | proc Z3_params_to_string*(c: Z3_context,p: Z3_params): Z3_string {.importc: "Z3_params_to_string", dynlib: libz3.} 144 | proc Z3_params_validate*(c: Z3_context,p: Z3_params,d: Z3_param_descrs) {.importc: "Z3_params_validate", dynlib: libz3.} 145 | proc Z3_param_descrs_inc_ref*(c: Z3_context,p: Z3_param_descrs) {.importc: "Z3_param_descrs_inc_ref", dynlib: libz3.} 146 | proc Z3_param_descrs_dec_ref*(c: Z3_context,p: Z3_param_descrs) {.importc: "Z3_param_descrs_dec_ref", dynlib: libz3.} 147 | proc Z3_param_descrs_size*(c: Z3_context,p: Z3_param_descrs): cuint {.importc: "Z3_param_descrs_size", dynlib: libz3.} 148 | proc Z3_param_descrs_get_name*(c: Z3_context,p: Z3_param_descrs,i: cuint): Z3_symbol {.importc: "Z3_param_descrs_get_name", dynlib: libz3.} 149 | proc Z3_param_descrs_to_string*(c: Z3_context,p: Z3_param_descrs): Z3_string {.importc: "Z3_param_descrs_to_string", dynlib: libz3.} 150 | proc Z3_mk_int_symbol*(c: Z3_context,i: cint): Z3_symbol {.importc: "Z3_mk_int_symbol", dynlib: libz3.} 151 | proc Z3_mk_string_symbol*(c: Z3_context,s: Z3_string): Z3_symbol {.importc: "Z3_mk_string_symbol", dynlib: libz3.} 152 | proc Z3_mk_uninterpreted_sort*(c: Z3_context,s: Z3_symbol): Z3_sort {.importc: "Z3_mk_uninterpreted_sort", dynlib: libz3.} 153 | proc Z3_mk_bool_sort*(c: Z3_context): Z3_sort {.importc: "Z3_mk_bool_sort", dynlib: libz3.} 154 | proc Z3_mk_int_sort*(c: Z3_context): Z3_sort {.importc: "Z3_mk_int_sort", dynlib: libz3.} 155 | proc Z3_mk_real_sort*(c: Z3_context): Z3_sort {.importc: "Z3_mk_real_sort", dynlib: libz3.} 156 | proc Z3_mk_bv_sort*(c: Z3_context,sz: cuint): Z3_sort {.importc: "Z3_mk_bv_sort", dynlib: libz3.} 157 | proc Z3_mk_finite_domain_sort*(c: Z3_context,name: Z3_symbol,size: culonglong): Z3_sort {.importc: "Z3_mk_finite_domain_sort", dynlib: libz3.} 158 | proc Z3_mk_array_sort*(c: Z3_context,domain: Z3_sort,range: Z3_sort): Z3_sort {.importc: "Z3_mk_array_sort", dynlib: libz3.} 159 | proc Z3_mk_list_sort*(c: Z3_context,name: Z3_symbol,elem_sort: Z3_sort,nil_decl: ptr Z3_func_decl,is_nil_decl: ptr Z3_func_decl,cons_decl: ptr Z3_func_decl,is_cons_decl: ptr Z3_func_decl,head_decl: ptr Z3_func_decl,tail_decl: ptr Z3_func_decl): Z3_sort {.importc: "Z3_mk_list_sort", dynlib: libz3.} 160 | proc Z3_del_constructor*(c: Z3_context,constr: Z3_constructor) {.importc: "Z3_del_constructor", dynlib: libz3.} 161 | proc Z3_del_constructor_list*(c: Z3_context,clist: Z3_constructor_list) {.importc: "Z3_del_constructor_list", dynlib: libz3.} 162 | proc Z3_mk_const*(c: Z3_context,s: Z3_symbol,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_const", dynlib: libz3.} 163 | proc Z3_mk_fresh_const*(c: Z3_context,prefix: Z3_string,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fresh_const", dynlib: libz3.} 164 | proc Z3_mk_true*(c: Z3_context): Z3_ast {.importc: "Z3_mk_true", dynlib: libz3.} 165 | proc Z3_mk_false*(c: Z3_context): Z3_ast {.importc: "Z3_mk_false", dynlib: libz3.} 166 | proc Z3_mk_eq*(c: Z3_context,l: Z3_ast,r: Z3_ast): Z3_ast {.importc: "Z3_mk_eq", dynlib: libz3.} 167 | proc Z3_mk_not*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_mk_not", dynlib: libz3.} 168 | proc Z3_mk_ite*(c: Z3_context,t1: Z3_ast,t2: Z3_ast,t3: Z3_ast): Z3_ast {.importc: "Z3_mk_ite", dynlib: libz3.} 169 | proc Z3_mk_iff*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_iff", dynlib: libz3.} 170 | proc Z3_mk_implies*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_implies", dynlib: libz3.} 171 | proc Z3_mk_xor*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_xor", dynlib: libz3.} 172 | proc Z3_mk_and*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_and", dynlib: libz3.} 173 | proc Z3_mk_add*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_add", dynlib: libz3.} 174 | proc Z3_mk_mul*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_mul", dynlib: libz3.} 175 | proc Z3_mk_distinct*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_distinct", dynlib: libz3.} 176 | proc Z3_mk_union*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_union", dynlib: libz3.} 177 | proc Z3_mk_intersect*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_intersect", dynlib: libz3.} 178 | proc Z3_mk_sub*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_sub", dynlib: libz3.} 179 | proc Z3_mk_or*(c: Z3_context,num_args: cuint, args: ptr Z3_ast): Z3_ast {.importc: "Z3_mk_or", dynlib: libz3.} 180 | proc Z3_mk_unary_minus*(c: Z3_context,arg: Z3_ast): Z3_ast {.importc: "Z3_mk_unary_minus", dynlib: libz3.} 181 | proc Z3_mk_div*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_div", dynlib: libz3.} 182 | proc Z3_mk_mod*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_mod", dynlib: libz3.} 183 | proc Z3_mk_rem*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_rem", dynlib: libz3.} 184 | proc Z3_mk_power*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_power", dynlib: libz3.} 185 | proc Z3_mk_lt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_lt", dynlib: libz3.} 186 | proc Z3_mk_le*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_le", dynlib: libz3.} 187 | proc Z3_mk_gt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_gt", dynlib: libz3.} 188 | proc Z3_mk_ge*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_ge", dynlib: libz3.} 189 | proc Z3_mk_int2real*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_int2real", dynlib: libz3.} 190 | proc Z3_mk_real2int*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_real2int", dynlib: libz3.} 191 | proc Z3_mk_is_int*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_is_int", dynlib: libz3.} 192 | proc Z3_mk_bvnot*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_bvnot", dynlib: libz3.} 193 | proc Z3_mk_bvredand*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_bvredand", dynlib: libz3.} 194 | proc Z3_mk_bvredor*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_bvredor", dynlib: libz3.} 195 | proc Z3_mk_bvand*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvand", dynlib: libz3.} 196 | proc Z3_mk_bvor*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvor", dynlib: libz3.} 197 | proc Z3_mk_bvxor*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvxor", dynlib: libz3.} 198 | proc Z3_mk_bvnand*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvnand", dynlib: libz3.} 199 | proc Z3_mk_bvnor*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvnor", dynlib: libz3.} 200 | proc Z3_mk_bvxnor*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvxnor", dynlib: libz3.} 201 | proc Z3_mk_bvneg*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_bvneg", dynlib: libz3.} 202 | proc Z3_mk_bvadd*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvadd", dynlib: libz3.} 203 | proc Z3_mk_bvsub*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsub", dynlib: libz3.} 204 | proc Z3_mk_bvmul*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvmul", dynlib: libz3.} 205 | proc Z3_mk_bvudiv*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvudiv", dynlib: libz3.} 206 | proc Z3_mk_bvsdiv*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsdiv", dynlib: libz3.} 207 | proc Z3_mk_bvurem*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvurem", dynlib: libz3.} 208 | proc Z3_mk_bvsrem*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsrem", dynlib: libz3.} 209 | proc Z3_mk_bvsmod*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsmod", dynlib: libz3.} 210 | proc Z3_mk_bvult*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvult", dynlib: libz3.} 211 | proc Z3_mk_bvslt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvslt", dynlib: libz3.} 212 | proc Z3_mk_bvule*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvule", dynlib: libz3.} 213 | proc Z3_mk_bvsle*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsle", dynlib: libz3.} 214 | proc Z3_mk_bvuge*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvuge", dynlib: libz3.} 215 | proc Z3_mk_bvsge*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsge", dynlib: libz3.} 216 | proc Z3_mk_bvugt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvugt", dynlib: libz3.} 217 | proc Z3_mk_bvsgt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsgt", dynlib: libz3.} 218 | proc Z3_mk_concat*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_concat", dynlib: libz3.} 219 | proc Z3_mk_extract*(c: Z3_context,high: cuint,low: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_extract", dynlib: libz3.} 220 | proc Z3_mk_sign_ext*(c: Z3_context,i: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_sign_ext", dynlib: libz3.} 221 | proc Z3_mk_zero_ext*(c: Z3_context,i: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_zero_ext", dynlib: libz3.} 222 | proc Z3_mk_repeat*(c: Z3_context,i: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_repeat", dynlib: libz3.} 223 | proc Z3_mk_bvshl*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvshl", dynlib: libz3.} 224 | proc Z3_mk_bvlshr*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvlshr", dynlib: libz3.} 225 | proc Z3_mk_bvashr*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvashr", dynlib: libz3.} 226 | proc Z3_mk_rotate_left*(c: Z3_context,i: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_rotate_left", dynlib: libz3.} 227 | proc Z3_mk_rotate_right*(c: Z3_context,i: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_rotate_right", dynlib: libz3.} 228 | proc Z3_mk_ext_rotate_left*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_ext_rotate_left", dynlib: libz3.} 229 | proc Z3_mk_ext_rotate_right*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_ext_rotate_right", dynlib: libz3.} 230 | proc Z3_mk_int2bv*(c: Z3_context,n: cuint,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_int2bv", dynlib: libz3.} 231 | proc Z3_mk_bv2int*(c: Z3_context,t1: Z3_ast,is_signed: Z3_bool): Z3_ast {.importc: "Z3_mk_bv2int", dynlib: libz3.} 232 | proc Z3_mk_bvadd_no_overflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast,is_signed: Z3_bool): Z3_ast {.importc: "Z3_mk_bvadd_no_overflow", dynlib: libz3.} 233 | proc Z3_mk_bvadd_no_underflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvadd_no_underflow", dynlib: libz3.} 234 | proc Z3_mk_bvsub_no_overflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsub_no_overflow", dynlib: libz3.} 235 | proc Z3_mk_bvsub_no_underflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast,is_signed: Z3_bool): Z3_ast {.importc: "Z3_mk_bvsub_no_underflow", dynlib: libz3.} 236 | proc Z3_mk_bvsdiv_no_overflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvsdiv_no_overflow", dynlib: libz3.} 237 | proc Z3_mk_bvneg_no_overflow*(c: Z3_context,t1: Z3_ast): Z3_ast {.importc: "Z3_mk_bvneg_no_overflow", dynlib: libz3.} 238 | proc Z3_mk_bvmul_no_overflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast,is_signed: Z3_bool): Z3_ast {.importc: "Z3_mk_bvmul_no_overflow", dynlib: libz3.} 239 | proc Z3_mk_bvmul_no_underflow*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_bvmul_no_underflow", dynlib: libz3.} 240 | proc Z3_mk_select*(c: Z3_context,a: Z3_ast,i: Z3_ast): Z3_ast {.importc: "Z3_mk_select", dynlib: libz3.} 241 | proc Z3_mk_store*(c: Z3_context,a: Z3_ast,i: Z3_ast,v: Z3_ast): Z3_ast {.importc: "Z3_mk_store", dynlib: libz3.} 242 | proc Z3_mk_const_array*(c: Z3_context,domain: Z3_sort,v: Z3_ast): Z3_ast {.importc: "Z3_mk_const_array", dynlib: libz3.} 243 | proc Z3_mk_array_default*(c: Z3_context,array: Z3_ast): Z3_ast {.importc: "Z3_mk_array_default", dynlib: libz3.} 244 | proc Z3_mk_set_sort*(c: Z3_context,ty: Z3_sort): Z3_sort {.importc: "Z3_mk_set_sort", dynlib: libz3.} 245 | proc Z3_mk_empty_set*(c: Z3_context,domain: Z3_sort): Z3_ast {.importc: "Z3_mk_empty_set", dynlib: libz3.} 246 | proc Z3_mk_full_set*(c: Z3_context,domain: Z3_sort): Z3_ast {.importc: "Z3_mk_full_set", dynlib: libz3.} 247 | proc Z3_mk_set_add*(c: Z3_context,set: Z3_ast,elem: Z3_ast): Z3_ast {.importc: "Z3_mk_set_add", dynlib: libz3.} 248 | proc Z3_mk_set_del*(c: Z3_context,set: Z3_ast,elem: Z3_ast): Z3_ast {.importc: "Z3_mk_set_del", dynlib: libz3.} 249 | proc Z3_mk_set_difference*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_set_difference", dynlib: libz3.} 250 | proc Z3_mk_set_complement*(c: Z3_context,arg: Z3_ast): Z3_ast {.importc: "Z3_mk_set_complement", dynlib: libz3.} 251 | proc Z3_mk_set_member*(c: Z3_context,elem: Z3_ast,set: Z3_ast): Z3_ast {.importc: "Z3_mk_set_member", dynlib: libz3.} 252 | proc Z3_mk_set_subset*(c: Z3_context,arg1: Z3_ast,arg2: Z3_ast): Z3_ast {.importc: "Z3_mk_set_subset", dynlib: libz3.} 253 | proc Z3_mk_numeral*(c: Z3_context,numeral: Z3_string,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_numeral", dynlib: libz3.} 254 | proc Z3_mk_real*(c: Z3_context,num: cint,den: cint): Z3_ast {.importc: "Z3_mk_real", dynlib: libz3.} 255 | proc Z3_mk_int*(c: Z3_context,v: cint,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_int", dynlib: libz3.} 256 | proc Z3_mk_unsigned_int*(c: Z3_context,v: cuint,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_unsigned_int", dynlib: libz3.} 257 | proc Z3_mk_int64*(c: Z3_context,v: clonglong,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_int64", dynlib: libz3.} 258 | proc Z3_mk_unsigned_int64*(c: Z3_context,v: culonglong,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_unsigned_int64", dynlib: libz3.} 259 | proc Z3_mk_exists*(c: Z3_context,weight: cuint, num_patterns: cuint, patterns: ptr Z3_pattern, num_decls: cuint, sorts: ptr Z3_sort, decl_names: ptr Z3_symbol, body: Z3_ast): Z3_ast {.importc: "Z3_mk_exists", dynlib: libz3.} 260 | proc Z3_mk_bound*(c: Z3_context,index: cuint,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_bound", dynlib: libz3.} 261 | proc Z3_get_symbol_kind*(c: Z3_context,s: Z3_symbol): Z3_symbol_kind {.importc: "Z3_get_symbol_kind", dynlib: libz3.} 262 | proc Z3_get_symbol_int*(c: Z3_context,s: Z3_symbol): cint {.importc: "Z3_get_symbol_int", dynlib: libz3.} 263 | proc Z3_get_symbol_string*(c: Z3_context,s: Z3_symbol): Z3_string {.importc: "Z3_get_symbol_string", dynlib: libz3.} 264 | proc Z3_get_sort_name*(c: Z3_context,d: Z3_sort): Z3_symbol {.importc: "Z3_get_sort_name", dynlib: libz3.} 265 | proc Z3_get_sort_id*(c: Z3_context,s: Z3_sort): cuint {.importc: "Z3_get_sort_id", dynlib: libz3.} 266 | proc Z3_sort_to_ast*(c: Z3_context,s: Z3_sort): Z3_ast {.importc: "Z3_sort_to_ast", dynlib: libz3.} 267 | proc Z3_is_eq_sort*(c: Z3_context,s1: Z3_sort,s2: Z3_sort): Z3_bool {.importc: "Z3_is_eq_sort", dynlib: libz3.} 268 | proc Z3_get_bv_sort_size*(c: Z3_context,t: Z3_sort): cuint {.importc: "Z3_get_bv_sort_size", dynlib: libz3.} 269 | proc Z3_get_finite_domain_sort_size*(c: Z3_context,s: Z3_sort,r: ptr culonglong): Z3_bool {.importc: "Z3_get_finite_domain_sort_size", dynlib: libz3.} 270 | proc Z3_get_array_sort_domain*(c: Z3_context,t: Z3_sort): Z3_sort {.importc: "Z3_get_array_sort_domain", dynlib: libz3.} 271 | proc Z3_get_array_sort_range*(c: Z3_context,t: Z3_sort): Z3_sort {.importc: "Z3_get_array_sort_range", dynlib: libz3.} 272 | proc Z3_get_tuple_sort_mk_decl*(c: Z3_context,t: Z3_sort): Z3_func_decl {.importc: "Z3_get_tuple_sort_mk_decl", dynlib: libz3.} 273 | proc Z3_get_tuple_sort_num_fields*(c: Z3_context,t: Z3_sort): cuint {.importc: "Z3_get_tuple_sort_num_fields", dynlib: libz3.} 274 | proc Z3_get_tuple_sort_field_decl*(c: Z3_context,t: Z3_sort,i: cuint): Z3_func_decl {.importc: "Z3_get_tuple_sort_field_decl", dynlib: libz3.} 275 | proc Z3_get_datatype_sort_num_constructors*(c: Z3_context,t: Z3_sort): cuint {.importc: "Z3_get_datatype_sort_num_constructors", dynlib: libz3.} 276 | proc Z3_get_datatype_sort_constructor*(c: Z3_context,t: Z3_sort,idx: cuint): Z3_func_decl {.importc: "Z3_get_datatype_sort_constructor", dynlib: libz3.} 277 | proc Z3_get_datatype_sort_recognizer*(c: Z3_context,t: Z3_sort,idx: cuint): Z3_func_decl {.importc: "Z3_get_datatype_sort_recognizer", dynlib: libz3.} 278 | proc Z3_get_datatype_sort_constructor_accessor*(c: Z3_context,t: Z3_sort,idx_c: cuint,idx_a: cuint): Z3_func_decl {.importc: "Z3_get_datatype_sort_constructor_accessor", dynlib: libz3.} 279 | proc Z3_datatype_update_field*(c: Z3_context,field_access: Z3_func_decl,t: Z3_ast,value: Z3_ast): Z3_ast {.importc: "Z3_datatype_update_field", dynlib: libz3.} 280 | proc Z3_get_relation_arity*(c: Z3_context,s: Z3_sort): cuint {.importc: "Z3_get_relation_arity", dynlib: libz3.} 281 | proc Z3_get_relation_column*(c: Z3_context,s: Z3_sort,col: cuint): Z3_sort {.importc: "Z3_get_relation_column", dynlib: libz3.} 282 | proc Z3_func_decl_to_ast*(c: Z3_context,f: Z3_func_decl): Z3_ast {.importc: "Z3_func_decl_to_ast", dynlib: libz3.} 283 | proc Z3_is_eq_func_decl*(c: Z3_context,f1: Z3_func_decl,f2: Z3_func_decl): Z3_bool {.importc: "Z3_is_eq_func_decl", dynlib: libz3.} 284 | proc Z3_get_func_decl_id*(c: Z3_context,f: Z3_func_decl): cuint {.importc: "Z3_get_func_decl_id", dynlib: libz3.} 285 | proc Z3_get_decl_name*(c: Z3_context,d: Z3_func_decl): Z3_symbol {.importc: "Z3_get_decl_name", dynlib: libz3.} 286 | proc Z3_get_decl_kind*(c: Z3_context,d: Z3_func_decl): Z3_decl_kind {.importc: "Z3_get_decl_kind", dynlib: libz3.} 287 | proc Z3_get_domain_size*(c: Z3_context,d: Z3_func_decl): cuint {.importc: "Z3_get_domain_size", dynlib: libz3.} 288 | proc Z3_get_arity*(c: Z3_context,d: Z3_func_decl): cuint {.importc: "Z3_get_arity", dynlib: libz3.} 289 | proc Z3_get_domain*(c: Z3_context,d: Z3_func_decl,i: cuint): Z3_sort {.importc: "Z3_get_domain", dynlib: libz3.} 290 | proc Z3_get_range*(c: Z3_context,d: Z3_func_decl): Z3_sort {.importc: "Z3_get_range", dynlib: libz3.} 291 | proc Z3_get_decl_num_parameters*(c: Z3_context,d: Z3_func_decl): cuint {.importc: "Z3_get_decl_num_parameters", dynlib: libz3.} 292 | proc Z3_get_decl_int_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): cint {.importc: "Z3_get_decl_int_parameter", dynlib: libz3.} 293 | proc Z3_get_decl_double_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): cdouble {.importc: "Z3_get_decl_double_parameter", dynlib: libz3.} 294 | proc Z3_get_decl_symbol_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): Z3_symbol {.importc: "Z3_get_decl_symbol_parameter", dynlib: libz3.} 295 | proc Z3_get_decl_sort_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): Z3_sort {.importc: "Z3_get_decl_sort_parameter", dynlib: libz3.} 296 | proc Z3_get_decl_ast_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): Z3_ast {.importc: "Z3_get_decl_ast_parameter", dynlib: libz3.} 297 | proc Z3_get_decl_func_decl_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): Z3_func_decl {.importc: "Z3_get_decl_func_decl_parameter", dynlib: libz3.} 298 | proc Z3_get_decl_rational_parameter*(c: Z3_context,d: Z3_func_decl,idx: cuint): Z3_string {.importc: "Z3_get_decl_rational_parameter", dynlib: libz3.} 299 | proc Z3_app_to_ast*(c: Z3_context,a: Z3_app): Z3_ast {.importc: "Z3_app_to_ast", dynlib: libz3.} 300 | proc Z3_get_app_decl*(c: Z3_context,a: Z3_app): Z3_func_decl {.importc: "Z3_get_app_decl", dynlib: libz3.} 301 | proc Z3_get_app_num_args*(c: Z3_context,a: Z3_app): cuint {.importc: "Z3_get_app_num_args", dynlib: libz3.} 302 | proc Z3_get_app_arg*(c: Z3_context,a: Z3_app,i: cuint): Z3_ast {.importc: "Z3_get_app_arg", dynlib: libz3.} 303 | proc Z3_is_eq_ast*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_bool {.importc: "Z3_is_eq_ast", dynlib: libz3.} 304 | proc Z3_get_ast_id*(c: Z3_context,t: Z3_ast): cuint {.importc: "Z3_get_ast_id", dynlib: libz3.} 305 | proc Z3_get_ast_hash*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_ast_hash", dynlib: libz3.} 306 | proc Z3_get_sort*(c: Z3_context,a: Z3_ast): Z3_sort {.importc: "Z3_get_sort", dynlib: libz3.} 307 | proc Z3_get_sort_kind*(c: Z3_context, t: Z3_sort): Z3_sort_kind {.importc: "Z3_get_sort_kind", dynlib: libz3.} 308 | proc Z3_is_well_sorted*(c: Z3_context,t: Z3_ast): Z3_bool {.importc: "Z3_is_well_sorted", dynlib: libz3.} 309 | proc Z3_get_bool_value*(c: Z3_context,a: Z3_ast): Z3_lbool {.importc: "Z3_get_bool_value", dynlib: libz3.} 310 | proc Z3_is_app*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_is_app", dynlib: libz3.} 311 | proc Z3_is_numeral_ast*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_is_numeral_ast", dynlib: libz3.} 312 | proc Z3_is_algebraic_number*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_is_algebraic_number", dynlib: libz3.} 313 | proc Z3_to_app*(c: Z3_context,a: Z3_ast): Z3_app {.importc: "Z3_to_app", dynlib: libz3.} 314 | proc Z3_to_func_decl*(c: Z3_context,a: Z3_ast): Z3_func_decl {.importc: "Z3_to_func_decl", dynlib: libz3.} 315 | proc Z3_get_numeral_string*(c: Z3_context,a: Z3_ast): Z3_string {.importc: "Z3_get_numeral_string", dynlib: libz3.} 316 | proc Z3_get_numeral_decimal_string*(c: Z3_context,a: Z3_ast,precision: cuint): Z3_string {.importc: "Z3_get_numeral_decimal_string", dynlib: libz3.} 317 | proc Z3_get_numerator*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_get_numerator", dynlib: libz3.} 318 | proc Z3_get_denominator*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_get_denominator", dynlib: libz3.} 319 | proc Z3_get_numeral_small*(c: Z3_context,a: Z3_ast,num: ptr clonglong,den: ptr clonglong): Z3_bool {.importc: "Z3_get_numeral_small", dynlib: libz3.} 320 | proc Z3_get_numeral_int*(c: Z3_context,v: Z3_ast,i: ptr cint): Z3_bool {.importc: "Z3_get_numeral_int", dynlib: libz3.} 321 | proc Z3_get_numeral_uint*(c: Z3_context,v: Z3_ast,u: ptr cuint): Z3_bool {.importc: "Z3_get_numeral_uint", dynlib: libz3.} 322 | proc Z3_get_numeral_uint64*(c: Z3_context,v: Z3_ast,u: ptr culonglong): Z3_bool {.importc: "Z3_get_numeral_uint64", dynlib: libz3.} 323 | proc Z3_get_numeral_int64*(c: Z3_context,v: Z3_ast,i: ptr clonglong): Z3_bool {.importc: "Z3_get_numeral_int64", dynlib: libz3.} 324 | proc Z3_get_numeral_rational_int64*(c: Z3_context,v: Z3_ast,num: ptr clonglong,den: ptr clonglong): Z3_bool {.importc: "Z3_get_numeral_rational_int64", dynlib: libz3.} 325 | proc Z3_get_algebraic_number_lower*(c: Z3_context,a: Z3_ast,precision: cuint): Z3_ast {.importc: "Z3_get_algebraic_number_lower", dynlib: libz3.} 326 | proc Z3_get_algebraic_number_upper*(c: Z3_context,a: Z3_ast,precision: cuint): Z3_ast {.importc: "Z3_get_algebraic_number_upper", dynlib: libz3.} 327 | proc Z3_pattern_to_ast*(c: Z3_context,p: Z3_pattern): Z3_ast {.importc: "Z3_pattern_to_ast", dynlib: libz3.} 328 | proc Z3_get_pattern_num_terms*(c: Z3_context,p: Z3_pattern): cuint {.importc: "Z3_get_pattern_num_terms", dynlib: libz3.} 329 | proc Z3_get_pattern*(c: Z3_context,p: Z3_pattern,idx: cuint): Z3_ast {.importc: "Z3_get_pattern", dynlib: libz3.} 330 | proc Z3_get_index_value*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_index_value", dynlib: libz3.} 331 | proc Z3_is_quantifier_forall*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_is_quantifier_forall", dynlib: libz3.} 332 | proc Z3_get_quantifier_weight*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_quantifier_weight", dynlib: libz3.} 333 | proc Z3_get_quantifier_num_patterns*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_quantifier_num_patterns", dynlib: libz3.} 334 | proc Z3_get_quantifier_pattern_ast*(c: Z3_context,a: Z3_ast,i: cuint): Z3_pattern {.importc: "Z3_get_quantifier_pattern_ast", dynlib: libz3.} 335 | proc Z3_get_quantifier_num_no_patterns*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_quantifier_num_no_patterns", dynlib: libz3.} 336 | proc Z3_get_quantifier_no_pattern_ast*(c: Z3_context,a: Z3_ast,i: cuint): Z3_ast {.importc: "Z3_get_quantifier_no_pattern_ast", dynlib: libz3.} 337 | proc Z3_get_quantifier_num_bound*(c: Z3_context,a: Z3_ast): cuint {.importc: "Z3_get_quantifier_num_bound", dynlib: libz3.} 338 | proc Z3_get_quantifier_bound_name*(c: Z3_context,a: Z3_ast,i: cuint): Z3_symbol {.importc: "Z3_get_quantifier_bound_name", dynlib: libz3.} 339 | proc Z3_get_quantifier_bound_sort*(c: Z3_context,a: Z3_ast,i: cuint): Z3_sort {.importc: "Z3_get_quantifier_bound_sort", dynlib: libz3.} 340 | proc Z3_get_quantifier_body*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_get_quantifier_body", dynlib: libz3.} 341 | proc Z3_simplify*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_simplify", dynlib: libz3.} 342 | proc Z3_simplify_ex*(c: Z3_context,a: Z3_ast,p: Z3_params): Z3_ast {.importc: "Z3_simplify_ex", dynlib: libz3.} 343 | proc Z3_simplify_get_help*(c: Z3_context): Z3_string {.importc: "Z3_simplify_get_help", dynlib: libz3.} 344 | proc Z3_simplify_get_param_descrs*(c: Z3_context): Z3_param_descrs {.importc: "Z3_simplify_get_param_descrs", dynlib: libz3.} 345 | proc Z3_translate*(source: Z3_context,a: Z3_ast,target: Z3_context): Z3_ast {.importc: "Z3_translate", dynlib: libz3.} 346 | proc Z3_model_inc_ref*(c: Z3_context,m: Z3_model) {.importc: "Z3_model_inc_ref", dynlib: libz3.} 347 | proc Z3_model_dec_ref*(c: Z3_context,m: Z3_model) {.importc: "Z3_model_dec_ref", dynlib: libz3.} 348 | proc Z3_model_eval*(c: Z3_context,m: Z3_model,t: Z3_ast,model_completion: Z3_bool,v: ptr Z3_ast): Z3_bool {.importc: "Z3_model_eval", dynlib: libz3.} 349 | proc Z3_model_get_const_interp*(c: Z3_context,m: Z3_model,a: Z3_func_decl): Z3_ast {.importc: "Z3_model_get_const_interp", dynlib: libz3.} 350 | proc Z3_model_has_interp*(c: Z3_context,m: Z3_model,a: Z3_func_decl): Z3_bool {.importc: "Z3_model_has_interp", dynlib: libz3.} 351 | proc Z3_model_get_func_interp*(c: Z3_context,m: Z3_model,f: Z3_func_decl): Z3_func_interp {.importc: "Z3_model_get_func_interp", dynlib: libz3.} 352 | proc Z3_model_get_num_consts*(c: Z3_context,m: Z3_model): cuint {.importc: "Z3_model_get_num_consts", dynlib: libz3.} 353 | proc Z3_model_get_const_decl*(c: Z3_context,m: Z3_model,i: cuint): Z3_func_decl {.importc: "Z3_model_get_const_decl", dynlib: libz3.} 354 | proc Z3_model_get_num_funcs*(c: Z3_context,m: Z3_model): cuint {.importc: "Z3_model_get_num_funcs", dynlib: libz3.} 355 | proc Z3_model_get_func_decl*(c: Z3_context,m: Z3_model,i: cuint): Z3_func_decl {.importc: "Z3_model_get_func_decl", dynlib: libz3.} 356 | proc Z3_model_get_num_sorts*(c: Z3_context,m: Z3_model): cuint {.importc: "Z3_model_get_num_sorts", dynlib: libz3.} 357 | proc Z3_model_get_sort*(c: Z3_context,m: Z3_model,i: cuint): Z3_sort {.importc: "Z3_model_get_sort", dynlib: libz3.} 358 | proc Z3_model_get_sort_universe*(c: Z3_context,m: Z3_model,s: Z3_sort): Z3_ast_vector {.importc: "Z3_model_get_sort_universe", dynlib: libz3.} 359 | proc Z3_is_as_array*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_is_as_array", dynlib: libz3.} 360 | proc Z3_get_as_array_func_decl*(c: Z3_context,a: Z3_ast): Z3_func_decl {.importc: "Z3_get_as_array_func_decl", dynlib: libz3.} 361 | proc Z3_func_interp_inc_ref*(c: Z3_context,f: Z3_func_interp) {.importc: "Z3_func_interp_inc_ref", dynlib: libz3.} 362 | proc Z3_func_interp_dec_ref*(c: Z3_context,f: Z3_func_interp) {.importc: "Z3_func_interp_dec_ref", dynlib: libz3.} 363 | proc Z3_func_interp_get_num_entries*(c: Z3_context,f: Z3_func_interp): cuint {.importc: "Z3_func_interp_get_num_entries", dynlib: libz3.} 364 | proc Z3_func_interp_get_entry*(c: Z3_context,f: Z3_func_interp,i: cuint): Z3_func_entry {.importc: "Z3_func_interp_get_entry", dynlib: libz3.} 365 | proc Z3_func_interp_get_else*(c: Z3_context,f: Z3_func_interp): Z3_ast {.importc: "Z3_func_interp_get_else", dynlib: libz3.} 366 | proc Z3_func_interp_get_arity*(c: Z3_context,f: Z3_func_interp): cuint {.importc: "Z3_func_interp_get_arity", dynlib: libz3.} 367 | proc Z3_func_entry_inc_ref*(c: Z3_context,e: Z3_func_entry) {.importc: "Z3_func_entry_inc_ref", dynlib: libz3.} 368 | proc Z3_func_entry_dec_ref*(c: Z3_context,e: Z3_func_entry) {.importc: "Z3_func_entry_dec_ref", dynlib: libz3.} 369 | proc Z3_func_entry_get_value*(c: Z3_context,e: Z3_func_entry): Z3_ast {.importc: "Z3_func_entry_get_value", dynlib: libz3.} 370 | proc Z3_func_entry_get_num_args*(c: Z3_context,e: Z3_func_entry): cuint {.importc: "Z3_func_entry_get_num_args", dynlib: libz3.} 371 | proc Z3_func_entry_get_arg*(c: Z3_context,e: Z3_func_entry,i: cuint): Z3_ast {.importc: "Z3_func_entry_get_arg", dynlib: libz3.} 372 | proc Z3_open_log*(filename: Z3_string): Z3_bool {.importc: "Z3_open_log", dynlib: libz3.} 373 | proc Z3_append_log*(string: Z3_string) {.importc: "Z3_append_log", dynlib: libz3.} 374 | proc Z3_close_log*() {.importc: "Z3_close_log", dynlib: libz3.} 375 | proc Z3_toggle_warning_messages*(enabled: Z3_bool) {.importc: "Z3_toggle_warning_messages", dynlib: libz3.} 376 | proc Z3_set_ast_print_mode*(c: Z3_context,mode: Z3_ast_print_mode) {.importc: "Z3_set_ast_print_mode", dynlib: libz3.} 377 | proc Z3_ast_to_string*(c: Z3_context,a: Z3_ast): Z3_string {.importc: "Z3_ast_to_string", dynlib: libz3.} 378 | proc Z3_pattern_to_string*(c: Z3_context,p: Z3_pattern): Z3_string {.importc: "Z3_pattern_to_string", dynlib: libz3.} 379 | proc Z3_sort_to_string*(c: Z3_context,s: Z3_sort): Z3_string {.importc: "Z3_sort_to_string", dynlib: libz3.} 380 | proc Z3_func_decl_to_string*(c: Z3_context,d: Z3_func_decl): Z3_string {.importc: "Z3_func_decl_to_string", dynlib: libz3.} 381 | proc Z3_model_to_string*(c: Z3_context,m: Z3_model): Z3_string {.importc: "Z3_model_to_string", dynlib: libz3.} 382 | proc Z3_get_smtlib_num_formulas*(c: Z3_context): cuint {.importc: "Z3_get_smtlib_num_formulas", dynlib: libz3.} 383 | proc Z3_get_smtlib_formula*(c: Z3_context,i: cuint): Z3_ast {.importc: "Z3_get_smtlib_formula", dynlib: libz3.} 384 | proc Z3_get_smtlib_num_assumptions*(c: Z3_context): cuint {.importc: "Z3_get_smtlib_num_assumptions", dynlib: libz3.} 385 | proc Z3_get_smtlib_assumption*(c: Z3_context,i: cuint): Z3_ast {.importc: "Z3_get_smtlib_assumption", dynlib: libz3.} 386 | proc Z3_get_smtlib_num_decls*(c: Z3_context): cuint {.importc: "Z3_get_smtlib_num_decls", dynlib: libz3.} 387 | proc Z3_get_smtlib_decl*(c: Z3_context,i: cuint): Z3_func_decl {.importc: "Z3_get_smtlib_decl", dynlib: libz3.} 388 | proc Z3_get_smtlib_num_sorts*(c: Z3_context): cuint {.importc: "Z3_get_smtlib_num_sorts", dynlib: libz3.} 389 | proc Z3_get_smtlib_sort*(c: Z3_context,i: cuint): Z3_sort {.importc: "Z3_get_smtlib_sort", dynlib: libz3.} 390 | proc Z3_get_smtlib_error*(c: Z3_context): Z3_string {.importc: "Z3_get_smtlib_error", dynlib: libz3.} 391 | proc Z3_get_error_code*(c: Z3_context): Z3_error_code {.importc: "Z3_get_error_code", dynlib: libz3.} 392 | proc Z3_set_error_handler*(c: Z3_context,h: Z3_error_handler) {.importc: "Z3_set_error_handler", dynlib: libz3.} 393 | proc Z3_set_error*(c: Z3_context,e: Z3_error_code) {.importc: "Z3_set_error", dynlib: libz3.} 394 | proc Z3_get_error_msg*(c: Z3_context,err: Z3_error_code): Z3_string {.importc: "Z3_get_error_msg", dynlib: libz3.} 395 | proc Z3_get_version*(major: ptr cuint,minor: ptr cuint,build_number: ptr cuint,revision_number: ptr cuint) {.importc: "Z3_get_version", dynlib: libz3.} 396 | proc Z3_enable_trace*(tag: Z3_string) {.importc: "Z3_enable_trace", dynlib: libz3.} 397 | proc Z3_disable_trace*(tag: Z3_string) {.importc: "Z3_disable_trace", dynlib: libz3.} 398 | proc Z3_reset_memory*() {.importc: "Z3_reset_memory", dynlib: libz3.} 399 | proc Z3_finalize_memory*() {.importc: "Z3_finalize_memory", dynlib: libz3.} 400 | proc Z3_mk_theory*(c: Z3_context,th_name: Z3_string,data: Z3_theory_data): Z3_theory {.importc: "Z3_mk_theory", dynlib: libz3.} 401 | proc Z3_theory_get_ext_data*(t: Z3_theory): Z3_theory_data {.importc: "Z3_theory_get_ext_data", dynlib: libz3.} 402 | proc Z3_theory_mk_sort*(c: Z3_context,t: Z3_theory,s: Z3_symbol): Z3_sort {.importc: "Z3_theory_mk_sort", dynlib: libz3.} 403 | proc Z3_theory_mk_value*(c: Z3_context,t: Z3_theory,n: Z3_symbol,s: Z3_sort): Z3_ast {.importc: "Z3_theory_mk_value", dynlib: libz3.} 404 | proc Z3_theory_mk_constant*(c: Z3_context,t: Z3_theory,n: Z3_symbol,s: Z3_sort): Z3_ast {.importc: "Z3_theory_mk_constant", dynlib: libz3.} 405 | proc Z3_theory_get_context*(t: Z3_theory): Z3_context {.importc: "Z3_theory_get_context", dynlib: libz3.} 406 | proc Z3_set_delete_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_delete_callback", dynlib: libz3.} 407 | #proc Z3_set_reduce_app_callback*(t: Z3_theory,f: Z3_reduce_app_callback_fptr) {.importc: "Z3_set_reduce_app_callback", dynlib: libz3.} 408 | proc Z3_set_reduce_eq_callback*(t: Z3_theory,f: Z3_reduce_eq_callback_fptr) {.importc: "Z3_set_reduce_eq_callback", dynlib: libz3.} 409 | #proc Z3_set_reduce_distinct_callback*(t: Z3_theory,f: Z3_reduce_distinct_callback_fptr) {.importc: "Z3_set_reduce_distinct_callback", dynlib: libz3.} 410 | proc Z3_set_new_app_callback*(t: Z3_theory,f: Z3_theory_ast_callback_fptr) {.importc: "Z3_set_new_app_callback", dynlib: libz3.} 411 | proc Z3_set_new_elem_callback*(t: Z3_theory,f: Z3_theory_ast_callback_fptr) {.importc: "Z3_set_new_elem_callback", dynlib: libz3.} 412 | proc Z3_set_init_search_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_init_search_callback", dynlib: libz3.} 413 | proc Z3_set_push_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_push_callback", dynlib: libz3.} 414 | proc Z3_set_pop_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_pop_callback", dynlib: libz3.} 415 | proc Z3_set_restart_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_restart_callback", dynlib: libz3.} 416 | proc Z3_set_reset_callback*(t: Z3_theory,f: Z3_theory_callback_fptr) {.importc: "Z3_set_reset_callback", dynlib: libz3.} 417 | proc Z3_set_final_check_callback*(t: Z3_theory,f: Z3_theory_final_check_callback_fptr) {.importc: "Z3_set_final_check_callback", dynlib: libz3.} 418 | proc Z3_set_new_eq_callback*(t: Z3_theory,f: Z3_theory_ast_ast_callback_fptr) {.importc: "Z3_set_new_eq_callback", dynlib: libz3.} 419 | proc Z3_set_new_diseq_callback*(t: Z3_theory,f: Z3_theory_ast_ast_callback_fptr) {.importc: "Z3_set_new_diseq_callback", dynlib: libz3.} 420 | proc Z3_set_new_assignment_callback*(t: Z3_theory,f: Z3_theory_ast_bool_callback_fptr) {.importc: "Z3_set_new_assignment_callback", dynlib: libz3.} 421 | proc Z3_set_new_relevant_callback*(t: Z3_theory,f: Z3_theory_ast_callback_fptr) {.importc: "Z3_set_new_relevant_callback", dynlib: libz3.} 422 | proc Z3_theory_assert_axiom*(t: Z3_theory,ax: Z3_ast) {.importc: "Z3_theory_assert_axiom", dynlib: libz3.} 423 | proc Z3_theory_assume_eq*(t: Z3_theory,lhs: Z3_ast,rhs: Z3_ast) {.importc: "Z3_theory_assume_eq", dynlib: libz3.} 424 | proc Z3_theory_enable_axiom_simplification*(t: Z3_theory,flag: Z3_bool) {.importc: "Z3_theory_enable_axiom_simplification", dynlib: libz3.} 425 | proc Z3_theory_get_eqc_root*(t: Z3_theory,n: Z3_ast): Z3_ast {.importc: "Z3_theory_get_eqc_root", dynlib: libz3.} 426 | proc Z3_theory_get_eqc_next*(t: Z3_theory,n: Z3_ast): Z3_ast {.importc: "Z3_theory_get_eqc_next", dynlib: libz3.} 427 | proc Z3_theory_get_num_parents*(t: Z3_theory,n: Z3_ast): cuint {.importc: "Z3_theory_get_num_parents", dynlib: libz3.} 428 | proc Z3_theory_get_parent*(t: Z3_theory,n: Z3_ast,i: cuint): Z3_ast {.importc: "Z3_theory_get_parent", dynlib: libz3.} 429 | proc Z3_theory_is_value*(t: Z3_theory,n: Z3_ast): Z3_bool {.importc: "Z3_theory_is_value", dynlib: libz3.} 430 | proc Z3_theory_is_decl*(t: Z3_theory,d: Z3_func_decl): Z3_bool {.importc: "Z3_theory_is_decl", dynlib: libz3.} 431 | proc Z3_theory_get_num_elems*(t: Z3_theory): cuint {.importc: "Z3_theory_get_num_elems", dynlib: libz3.} 432 | proc Z3_theory_get_elem*(t: Z3_theory,i: cuint): Z3_ast {.importc: "Z3_theory_get_elem", dynlib: libz3.} 433 | proc Z3_theory_get_num_apps*(t: Z3_theory): cuint {.importc: "Z3_theory_get_num_apps", dynlib: libz3.} 434 | proc Z3_theory_get_app*(t: Z3_theory,i: cuint): Z3_ast {.importc: "Z3_theory_get_app", dynlib: libz3.} 435 | proc Z3_mk_fixedpoint*(c: Z3_context): Z3_fixedpoint {.importc: "Z3_mk_fixedpoint", dynlib: libz3.} 436 | proc Z3_fixedpoint_inc_ref*(c: Z3_context,d: Z3_fixedpoint) {.importc: "Z3_fixedpoint_inc_ref", dynlib: libz3.} 437 | proc Z3_fixedpoint_dec_ref*(c: Z3_context,d: Z3_fixedpoint) {.importc: "Z3_fixedpoint_dec_ref", dynlib: libz3.} 438 | proc Z3_fixedpoint_add_rule*(c: Z3_context,d: Z3_fixedpoint,rule: Z3_ast,name: Z3_symbol) {.importc: "Z3_fixedpoint_add_rule", dynlib: libz3.} 439 | proc Z3_fixedpoint_assert*(c: Z3_context,d: Z3_fixedpoint,axiom: Z3_ast) {.importc: "Z3_fixedpoint_assert", dynlib: libz3.} 440 | proc Z3_fixedpoint_query*(c: Z3_context,d: Z3_fixedpoint,query: Z3_ast): Z3_lbool {.importc: "Z3_fixedpoint_query", dynlib: libz3.} 441 | proc Z3_fixedpoint_get_answer*(c: Z3_context,d: Z3_fixedpoint): Z3_ast {.importc: "Z3_fixedpoint_get_answer", dynlib: libz3.} 442 | proc Z3_fixedpoint_get_reason_unknown*(c: Z3_context,d: Z3_fixedpoint): Z3_string {.importc: "Z3_fixedpoint_get_reason_unknown", dynlib: libz3.} 443 | proc Z3_fixedpoint_update_rule*(c: Z3_context,d: Z3_fixedpoint,a: Z3_ast,name: Z3_symbol) {.importc: "Z3_fixedpoint_update_rule", dynlib: libz3.} 444 | proc Z3_fixedpoint_get_num_levels*(c: Z3_context,d: Z3_fixedpoint,pred: Z3_func_decl): cuint {.importc: "Z3_fixedpoint_get_num_levels", dynlib: libz3.} 445 | proc Z3_fixedpoint_get_cover_delta*(c: Z3_context,d: Z3_fixedpoint,level: cint,pred: Z3_func_decl): Z3_ast {.importc: "Z3_fixedpoint_get_cover_delta", dynlib: libz3.} 446 | proc Z3_fixedpoint_add_cover*(c: Z3_context,d: Z3_fixedpoint,level: cint,pred: Z3_func_decl,property: Z3_ast) {.importc: "Z3_fixedpoint_add_cover", dynlib: libz3.} 447 | proc Z3_fixedpoint_get_statistics*(c: Z3_context,d: Z3_fixedpoint): Z3_stats {.importc: "Z3_fixedpoint_get_statistics", dynlib: libz3.} 448 | proc Z3_fixedpoint_register_relation*(c: Z3_context,d: Z3_fixedpoint,f: Z3_func_decl) {.importc: "Z3_fixedpoint_register_relation", dynlib: libz3.} 449 | proc Z3_fixedpoint_get_rules*(c: Z3_context,f: Z3_fixedpoint): Z3_ast_vector {.importc: "Z3_fixedpoint_get_rules", dynlib: libz3.} 450 | proc Z3_fixedpoint_get_assertions*(c: Z3_context,f: Z3_fixedpoint): Z3_ast_vector {.importc: "Z3_fixedpoint_get_assertions", dynlib: libz3.} 451 | proc Z3_fixedpoint_set_params*(c: Z3_context,f: Z3_fixedpoint,p: Z3_params) {.importc: "Z3_fixedpoint_set_params", dynlib: libz3.} 452 | proc Z3_fixedpoint_get_help*(c: Z3_context,f: Z3_fixedpoint): Z3_string {.importc: "Z3_fixedpoint_get_help", dynlib: libz3.} 453 | proc Z3_fixedpoint_get_param_descrs*(c: Z3_context,f: Z3_fixedpoint): Z3_param_descrs {.importc: "Z3_fixedpoint_get_param_descrs", dynlib: libz3.} 454 | proc Z3_fixedpoint_from_string*(c: Z3_context,f: Z3_fixedpoint,s: Z3_string): Z3_ast_vector {.importc: "Z3_fixedpoint_from_string", dynlib: libz3.} 455 | proc Z3_fixedpoint_from_file*(c: Z3_context,f: Z3_fixedpoint,s: Z3_string): Z3_ast_vector {.importc: "Z3_fixedpoint_from_file", dynlib: libz3.} 456 | proc Z3_fixedpoint_push*(c: Z3_context,d: Z3_fixedpoint) {.importc: "Z3_fixedpoint_push", dynlib: libz3.} 457 | proc Z3_fixedpoint_pop*(c: Z3_context,d: Z3_fixedpoint) {.importc: "Z3_fixedpoint_pop", dynlib: libz3.} 458 | proc Z3_fixedpoint_init*(c: Z3_context,d: Z3_fixedpoint,state: pointer) {.importc: "Z3_fixedpoint_init", dynlib: libz3.} 459 | #proc Z3_fixedpoint_set_reduce_assign_callback*(c: Z3_context,d: Z3_fixedpoint,cb: Z3_fixedpoint_reduce_assign_callback_fptr) {.importc: "Z3_fixedpoint_set_reduce_assign_callback", dynlib: libz3.} 460 | #proc Z3_fixedpoint_set_reduce_app_callback*(c: Z3_context,d: Z3_fixedpoint,cb: Z3_fixedpoint_reduce_app_callback_fptr) {.importc: "Z3_fixedpoint_set_reduce_app_callback", dynlib: libz3.} 461 | proc Z3_mk_optimize*(c: Z3_context): Z3_optimize {.importc: "Z3_mk_optimize", dynlib: libz3.} 462 | proc Z3_optimize_inc_ref*(c: Z3_context,d: Z3_optimize) {.importc: "Z3_optimize_inc_ref", dynlib: libz3.} 463 | proc Z3_optimize_dec_ref*(c: Z3_context,d: Z3_optimize) {.importc: "Z3_optimize_dec_ref", dynlib: libz3.} 464 | proc Z3_optimize_assert*(c: Z3_context,o: Z3_optimize,a: Z3_ast) {.importc: "Z3_optimize_assert", dynlib: libz3.} 465 | proc Z3_optimize_assert_soft*(c: Z3_context,o: Z3_optimize,a: Z3_ast,weight: Z3_string,id: Z3_symbol): cuint {.importc: "Z3_optimize_assert_soft", dynlib: libz3.} 466 | proc Z3_optimize_maximize*(c: Z3_context,o: Z3_optimize,t: Z3_ast): cuint {.importc: "Z3_optimize_maximize", dynlib: libz3.} 467 | proc Z3_optimize_minimize*(c: Z3_context,o: Z3_optimize,t: Z3_ast): cuint {.importc: "Z3_optimize_minimize", dynlib: libz3.} 468 | proc Z3_optimize_push*(c: Z3_context,d: Z3_optimize) {.importc: "Z3_optimize_push", dynlib: libz3.} 469 | proc Z3_optimize_pop*(c: Z3_context,d: Z3_optimize) {.importc: "Z3_optimize_pop", dynlib: libz3.} 470 | proc Z3_optimize_check*(c: Z3_context,o: Z3_optimize): Z3_lbool {.importc: "Z3_optimize_check", dynlib: libz3.} 471 | proc Z3_optimize_get_reason_unknown*(c: Z3_context,d: Z3_optimize): Z3_string {.importc: "Z3_optimize_get_reason_unknown", dynlib: libz3.} 472 | proc Z3_optimize_get_model*(c: Z3_context,o: Z3_optimize): Z3_model {.importc: "Z3_optimize_get_model", dynlib: libz3.} 473 | proc Z3_optimize_set_params*(c: Z3_context,o: Z3_optimize,p: Z3_params) {.importc: "Z3_optimize_set_params", dynlib: libz3.} 474 | proc Z3_optimize_get_param_descrs*(c: Z3_context,o: Z3_optimize): Z3_param_descrs {.importc: "Z3_optimize_get_param_descrs", dynlib: libz3.} 475 | proc Z3_optimize_get_lower*(c: Z3_context,o: Z3_optimize,idx: cuint): Z3_ast {.importc: "Z3_optimize_get_lower", dynlib: libz3.} 476 | proc Z3_optimize_get_upper*(c: Z3_context,o: Z3_optimize,idx: cuint): Z3_ast {.importc: "Z3_optimize_get_upper", dynlib: libz3.} 477 | proc Z3_optimize_to_string*(c: Z3_context,o: Z3_optimize): Z3_string {.importc: "Z3_optimize_to_string", dynlib: libz3.} 478 | proc Z3_optimize_get_help*(c: Z3_context,t: Z3_optimize): Z3_string {.importc: "Z3_optimize_get_help", dynlib: libz3.} 479 | proc Z3_optimize_get_statistics*(c: Z3_context,d: Z3_optimize): Z3_stats {.importc: "Z3_optimize_get_statistics", dynlib: libz3.} 480 | proc Z3_mk_ast_vector*(c: Z3_context): Z3_ast_vector {.importc: "Z3_mk_ast_vector", dynlib: libz3.} 481 | proc Z3_ast_vector_inc_ref*(c: Z3_context,v: Z3_ast_vector) {.importc: "Z3_ast_vector_inc_ref", dynlib: libz3.} 482 | proc Z3_ast_vector_dec_ref*(c: Z3_context,v: Z3_ast_vector) {.importc: "Z3_ast_vector_dec_ref", dynlib: libz3.} 483 | proc Z3_ast_vector_size*(c: Z3_context,v: Z3_ast_vector): cuint {.importc: "Z3_ast_vector_size", dynlib: libz3.} 484 | proc Z3_ast_vector_get*(c: Z3_context,v: Z3_ast_vector,i: cuint): Z3_ast {.importc: "Z3_ast_vector_get", dynlib: libz3.} 485 | proc Z3_ast_vector_set*(c: Z3_context,v: Z3_ast_vector,i: cuint,a: Z3_ast) {.importc: "Z3_ast_vector_set", dynlib: libz3.} 486 | proc Z3_ast_vector_resize*(c: Z3_context,v: Z3_ast_vector,n: cuint) {.importc: "Z3_ast_vector_resize", dynlib: libz3.} 487 | proc Z3_ast_vector_push*(c: Z3_context,v: Z3_ast_vector,a: Z3_ast) {.importc: "Z3_ast_vector_push", dynlib: libz3.} 488 | proc Z3_ast_vector_translate*(s: Z3_context,v: Z3_ast_vector,t: Z3_context): Z3_ast_vector {.importc: "Z3_ast_vector_translate", dynlib: libz3.} 489 | proc Z3_ast_vector_to_string*(c: Z3_context,v: Z3_ast_vector): Z3_string {.importc: "Z3_ast_vector_to_string", dynlib: libz3.} 490 | proc Z3_mk_ast_map*(c: Z3_context): Z3_ast_map {.importc: "Z3_mk_ast_map", dynlib: libz3.} 491 | proc Z3_ast_map_inc_ref*(c: Z3_context,m: Z3_ast_map) {.importc: "Z3_ast_map_inc_ref", dynlib: libz3.} 492 | proc Z3_ast_map_dec_ref*(c: Z3_context,m: Z3_ast_map) {.importc: "Z3_ast_map_dec_ref", dynlib: libz3.} 493 | proc Z3_ast_map_contains*(c: Z3_context,m: Z3_ast_map,k: Z3_ast): Z3_bool {.importc: "Z3_ast_map_contains", dynlib: libz3.} 494 | proc Z3_ast_map_find*(c: Z3_context,m: Z3_ast_map,k: Z3_ast): Z3_ast {.importc: "Z3_ast_map_find", dynlib: libz3.} 495 | proc Z3_ast_map_insert*(c: Z3_context,m: Z3_ast_map,k: Z3_ast,v: Z3_ast) {.importc: "Z3_ast_map_insert", dynlib: libz3.} 496 | proc Z3_ast_map_erase*(c: Z3_context,m: Z3_ast_map,k: Z3_ast) {.importc: "Z3_ast_map_erase", dynlib: libz3.} 497 | proc Z3_ast_map_reset*(c: Z3_context,m: Z3_ast_map) {.importc: "Z3_ast_map_reset", dynlib: libz3.} 498 | proc Z3_ast_map_size*(c: Z3_context,m: Z3_ast_map): cuint {.importc: "Z3_ast_map_size", dynlib: libz3.} 499 | proc Z3_ast_map_keys*(c: Z3_context,m: Z3_ast_map): Z3_ast_vector {.importc: "Z3_ast_map_keys", dynlib: libz3.} 500 | proc Z3_ast_map_to_string*(c: Z3_context,m: Z3_ast_map): Z3_string {.importc: "Z3_ast_map_to_string", dynlib: libz3.} 501 | proc Z3_mk_goal*(c: Z3_context,models: Z3_bool,unsat_cores: Z3_bool,proofs: Z3_bool): Z3_goal {.importc: "Z3_mk_goal", dynlib: libz3.} 502 | proc Z3_goal_inc_ref*(c: Z3_context,g: Z3_goal) {.importc: "Z3_goal_inc_ref", dynlib: libz3.} 503 | proc Z3_goal_dec_ref*(c: Z3_context,g: Z3_goal) {.importc: "Z3_goal_dec_ref", dynlib: libz3.} 504 | proc Z3_goal_precision*(c: Z3_context,g: Z3_goal): Z3_goal_prec {.importc: "Z3_goal_precision", dynlib: libz3.} 505 | proc Z3_goal_assert*(c: Z3_context,g: Z3_goal,a: Z3_ast) {.importc: "Z3_goal_assert", dynlib: libz3.} 506 | proc Z3_goal_inconsistent*(c: Z3_context,g: Z3_goal): Z3_bool {.importc: "Z3_goal_inconsistent", dynlib: libz3.} 507 | proc Z3_goal_depth*(c: Z3_context,g: Z3_goal): cuint {.importc: "Z3_goal_depth", dynlib: libz3.} 508 | proc Z3_goal_reset*(c: Z3_context,g: Z3_goal) {.importc: "Z3_goal_reset", dynlib: libz3.} 509 | proc Z3_goal_size*(c: Z3_context,g: Z3_goal): cuint {.importc: "Z3_goal_size", dynlib: libz3.} 510 | proc Z3_goal_formula*(c: Z3_context,g: Z3_goal,idx: cuint): Z3_ast {.importc: "Z3_goal_formula", dynlib: libz3.} 511 | proc Z3_goal_num_exprs*(c: Z3_context,g: Z3_goal): cuint {.importc: "Z3_goal_num_exprs", dynlib: libz3.} 512 | proc Z3_goal_is_decided_sat*(c: Z3_context,g: Z3_goal): Z3_bool {.importc: "Z3_goal_is_decided_sat", dynlib: libz3.} 513 | proc Z3_goal_is_decided_unsat*(c: Z3_context,g: Z3_goal): Z3_bool {.importc: "Z3_goal_is_decided_unsat", dynlib: libz3.} 514 | proc Z3_goal_translate*(source: Z3_context,g: Z3_goal,target: Z3_context): Z3_goal {.importc: "Z3_goal_translate", dynlib: libz3.} 515 | proc Z3_goal_to_string*(c: Z3_context,g: Z3_goal): Z3_string {.importc: "Z3_goal_to_string", dynlib: libz3.} 516 | proc Z3_mk_tactic*(c: Z3_context,name: Z3_string): Z3_tactic {.importc: "Z3_mk_tactic", dynlib: libz3.} 517 | proc Z3_tactic_inc_ref*(c: Z3_context,t: Z3_tactic) {.importc: "Z3_tactic_inc_ref", dynlib: libz3.} 518 | proc Z3_tactic_dec_ref*(c: Z3_context,g: Z3_tactic) {.importc: "Z3_tactic_dec_ref", dynlib: libz3.} 519 | proc Z3_mk_probe*(c: Z3_context,name: Z3_string): Z3_probe {.importc: "Z3_mk_probe", dynlib: libz3.} 520 | proc Z3_probe_inc_ref*(c: Z3_context,p: Z3_probe) {.importc: "Z3_probe_inc_ref", dynlib: libz3.} 521 | proc Z3_probe_dec_ref*(c: Z3_context,p: Z3_probe) {.importc: "Z3_probe_dec_ref", dynlib: libz3.} 522 | proc Z3_tactic_and_then*(c: Z3_context,t1: Z3_tactic,t2: Z3_tactic): Z3_tactic {.importc: "Z3_tactic_and_then", dynlib: libz3.} 523 | proc Z3_tactic_or_else*(c: Z3_context,t1: Z3_tactic,t2: Z3_tactic): Z3_tactic {.importc: "Z3_tactic_or_else", dynlib: libz3.} 524 | proc Z3_tactic_par_and_then*(c: Z3_context,t1: Z3_tactic,t2: Z3_tactic): Z3_tactic {.importc: "Z3_tactic_par_and_then", dynlib: libz3.} 525 | proc Z3_tactic_try_for*(c: Z3_context,t: Z3_tactic,ms: cuint): Z3_tactic {.importc: "Z3_tactic_try_for", dynlib: libz3.} 526 | proc Z3_tactic_when*(c: Z3_context,p: Z3_probe,t: Z3_tactic): Z3_tactic {.importc: "Z3_tactic_when", dynlib: libz3.} 527 | proc Z3_tactic_cond*(c: Z3_context,p: Z3_probe,t1: Z3_tactic,t2: Z3_tactic): Z3_tactic {.importc: "Z3_tactic_cond", dynlib: libz3.} 528 | proc Z3_tactic_repeat*(c: Z3_context,t: Z3_tactic,max: cuint): Z3_tactic {.importc: "Z3_tactic_repeat", dynlib: libz3.} 529 | proc Z3_tactic_skip*(c: Z3_context): Z3_tactic {.importc: "Z3_tactic_skip", dynlib: libz3.} 530 | proc Z3_tactic_fail*(c: Z3_context): Z3_tactic {.importc: "Z3_tactic_fail", dynlib: libz3.} 531 | proc Z3_tactic_fail_if*(c: Z3_context,p: Z3_probe): Z3_tactic {.importc: "Z3_tactic_fail_if", dynlib: libz3.} 532 | proc Z3_tactic_fail_if_not_decided*(c: Z3_context): Z3_tactic {.importc: "Z3_tactic_fail_if_not_decided", dynlib: libz3.} 533 | proc Z3_tactic_using_params*(c: Z3_context,t: Z3_tactic,p: Z3_params): Z3_tactic {.importc: "Z3_tactic_using_params", dynlib: libz3.} 534 | proc Z3_probe_const*(x: Z3_context,val: cdouble): Z3_probe {.importc: "Z3_probe_const", dynlib: libz3.} 535 | proc Z3_probe_lt*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_lt", dynlib: libz3.} 536 | proc Z3_probe_gt*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_gt", dynlib: libz3.} 537 | proc Z3_probe_le*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_le", dynlib: libz3.} 538 | proc Z3_probe_ge*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_ge", dynlib: libz3.} 539 | proc Z3_probe_eq*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_eq", dynlib: libz3.} 540 | proc Z3_probe_and*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_and", dynlib: libz3.} 541 | proc Z3_probe_or*(x: Z3_context,p1: Z3_probe,p2: Z3_probe): Z3_probe {.importc: "Z3_probe_or", dynlib: libz3.} 542 | proc Z3_probe_not*(x: Z3_context,p: Z3_probe): Z3_probe {.importc: "Z3_probe_not", dynlib: libz3.} 543 | proc Z3_get_num_tactics*(c: Z3_context): cuint {.importc: "Z3_get_num_tactics", dynlib: libz3.} 544 | proc Z3_get_tactic_name*(c: Z3_context,i: cuint): Z3_string {.importc: "Z3_get_tactic_name", dynlib: libz3.} 545 | proc Z3_get_num_probes*(c: Z3_context): cuint {.importc: "Z3_get_num_probes", dynlib: libz3.} 546 | proc Z3_get_probe_name*(c: Z3_context,i: cuint): Z3_string {.importc: "Z3_get_probe_name", dynlib: libz3.} 547 | proc Z3_tactic_get_help*(c: Z3_context,t: Z3_tactic): Z3_string {.importc: "Z3_tactic_get_help", dynlib: libz3.} 548 | proc Z3_tactic_get_param_descrs*(c: Z3_context,t: Z3_tactic): Z3_param_descrs {.importc: "Z3_tactic_get_param_descrs", dynlib: libz3.} 549 | proc Z3_tactic_get_descr*(c: Z3_context,name: Z3_string): Z3_string {.importc: "Z3_tactic_get_descr", dynlib: libz3.} 550 | proc Z3_probe_get_descr*(c: Z3_context,name: Z3_string): Z3_string {.importc: "Z3_probe_get_descr", dynlib: libz3.} 551 | proc Z3_probe_apply*(c: Z3_context,p: Z3_probe,g: Z3_goal): cdouble {.importc: "Z3_probe_apply", dynlib: libz3.} 552 | proc Z3_tactic_apply*(c: Z3_context,t: Z3_tactic,g: Z3_goal): Z3_apply_result {.importc: "Z3_tactic_apply", dynlib: libz3.} 553 | proc Z3_tactic_apply_ex*(c: Z3_context,t: Z3_tactic,g: Z3_goal,p: Z3_params): Z3_apply_result {.importc: "Z3_tactic_apply_ex", dynlib: libz3.} 554 | proc Z3_apply_result_inc_ref*(c: Z3_context,r: Z3_apply_result) {.importc: "Z3_apply_result_inc_ref", dynlib: libz3.} 555 | proc Z3_apply_result_dec_ref*(c: Z3_context,r: Z3_apply_result) {.importc: "Z3_apply_result_dec_ref", dynlib: libz3.} 556 | proc Z3_apply_result_to_string*(c: Z3_context,r: Z3_apply_result): Z3_string {.importc: "Z3_apply_result_to_string", dynlib: libz3.} 557 | proc Z3_apply_result_get_num_subgoals*(c: Z3_context,r: Z3_apply_result): cuint {.importc: "Z3_apply_result_get_num_subgoals", dynlib: libz3.} 558 | proc Z3_apply_result_get_subgoal*(c: Z3_context,r: Z3_apply_result,i: cuint): Z3_goal {.importc: "Z3_apply_result_get_subgoal", dynlib: libz3.} 559 | proc Z3_apply_result_convert_model*(c: Z3_context,r: Z3_apply_result,i: cuint,m: Z3_model): Z3_model {.importc: "Z3_apply_result_convert_model", dynlib: libz3.} 560 | proc Z3_mk_solver*(c: Z3_context): Z3_solver {.importc: "Z3_mk_solver", dynlib: libz3.} 561 | proc Z3_mk_simple_solver*(c: Z3_context): Z3_solver {.importc: "Z3_mk_simple_solver", dynlib: libz3.} 562 | proc Z3_mk_solver_for_logic*(c: Z3_context,logic: Z3_symbol): Z3_solver {.importc: "Z3_mk_solver_for_logic", dynlib: libz3.} 563 | proc Z3_mk_solver_from_tactic*(c: Z3_context,t: Z3_tactic): Z3_solver {.importc: "Z3_mk_solver_from_tactic", dynlib: libz3.} 564 | proc Z3_solver_get_help*(c: Z3_context,s: Z3_solver): Z3_string {.importc: "Z3_solver_get_help", dynlib: libz3.} 565 | proc Z3_solver_get_param_descrs*(c: Z3_context,s: Z3_solver): Z3_param_descrs {.importc: "Z3_solver_get_param_descrs", dynlib: libz3.} 566 | proc Z3_solver_set_params*(c: Z3_context,s: Z3_solver,p: Z3_params) {.importc: "Z3_solver_set_params", dynlib: libz3.} 567 | proc Z3_solver_inc_ref*(c: Z3_context,s: Z3_solver) {.importc: "Z3_solver_inc_ref", dynlib: libz3.} 568 | proc Z3_solver_dec_ref*(c: Z3_context,s: Z3_solver) {.importc: "Z3_solver_dec_ref", dynlib: libz3.} 569 | proc Z3_solver_push*(c: Z3_context,s: Z3_solver) {.importc: "Z3_solver_push", dynlib: libz3.} 570 | proc Z3_solver_pop*(c: Z3_context,s: Z3_solver,n: cuint) {.importc: "Z3_solver_pop", dynlib: libz3.} 571 | proc Z3_solver_reset*(c: Z3_context,s: Z3_solver) {.importc: "Z3_solver_reset", dynlib: libz3.} 572 | proc Z3_solver_get_num_scopes*(c: Z3_context,s: Z3_solver): cuint {.importc: "Z3_solver_get_num_scopes", dynlib: libz3.} 573 | proc Z3_solver_assert*(c: Z3_context,s: Z3_solver,a: Z3_ast) {.importc: "Z3_solver_assert", dynlib: libz3.} 574 | proc Z3_solver_assert_and_track*(c: Z3_context,s: Z3_solver,a: Z3_ast,p: Z3_ast) {.importc: "Z3_solver_assert_and_track", dynlib: libz3.} 575 | proc Z3_solver_get_assertions*(c: Z3_context,s: Z3_solver): Z3_ast_vector {.importc: "Z3_solver_get_assertions", dynlib: libz3.} 576 | proc Z3_solver_check*(c: Z3_context,s: Z3_solver): Z3_lbool {.importc: "Z3_solver_check", dynlib: libz3.} 577 | proc Z3_solver_get_model*(c: Z3_context,s: Z3_solver): Z3_model {.importc: "Z3_solver_get_model", dynlib: libz3.} 578 | proc Z3_solver_get_proof*(c: Z3_context,s: Z3_solver): Z3_ast {.importc: "Z3_solver_get_proof", dynlib: libz3.} 579 | proc Z3_solver_get_unsat_core*(c: Z3_context,s: Z3_solver): Z3_ast_vector {.importc: "Z3_solver_get_unsat_core", dynlib: libz3.} 580 | proc Z3_solver_get_reason_unknown*(c: Z3_context,s: Z3_solver): Z3_string {.importc: "Z3_solver_get_reason_unknown", dynlib: libz3.} 581 | proc Z3_solver_get_statistics*(c: Z3_context,s: Z3_solver): Z3_stats {.importc: "Z3_solver_get_statistics", dynlib: libz3.} 582 | proc Z3_solver_to_string*(c: Z3_context,s: Z3_solver): Z3_string {.importc: "Z3_solver_to_string", dynlib: libz3.} 583 | proc Z3_stats_to_string*(c: Z3_context,s: Z3_stats): Z3_string {.importc: "Z3_stats_to_string", dynlib: libz3.} 584 | proc Z3_stats_inc_ref*(c: Z3_context,s: Z3_stats) {.importc: "Z3_stats_inc_ref", dynlib: libz3.} 585 | proc Z3_stats_dec_ref*(c: Z3_context,s: Z3_stats) {.importc: "Z3_stats_dec_ref", dynlib: libz3.} 586 | proc Z3_stats_size*(c: Z3_context,s: Z3_stats): cuint {.importc: "Z3_stats_size", dynlib: libz3.} 587 | proc Z3_stats_get_key*(c: Z3_context,s: Z3_stats,idx: cuint): Z3_string {.importc: "Z3_stats_get_key", dynlib: libz3.} 588 | proc Z3_stats_is_uint*(c: Z3_context,s: Z3_stats,idx: cuint): Z3_bool {.importc: "Z3_stats_is_uint", dynlib: libz3.} 589 | proc Z3_stats_is_double*(c: Z3_context,s: Z3_stats,idx: cuint): Z3_bool {.importc: "Z3_stats_is_double", dynlib: libz3.} 590 | proc Z3_stats_get_uint_value*(c: Z3_context,s: Z3_stats,idx: cuint): cuint {.importc: "Z3_stats_get_uint_value", dynlib: libz3.} 591 | proc Z3_stats_get_double_value*(c: Z3_context,s: Z3_stats,idx: cuint): cdouble {.importc: "Z3_stats_get_double_value", dynlib: libz3.} 592 | proc Z3_set_logic*(c: Z3_context,logic: Z3_string): Z3_bool {.importc: "Z3_set_logic", dynlib: libz3.} 593 | proc Z3_push*(c: Z3_context) {.importc: "Z3_push", dynlib: libz3.} 594 | proc Z3_pop*(c: Z3_context,num_scopes: cuint) {.importc: "Z3_pop", dynlib: libz3.} 595 | proc Z3_get_num_scopes*(c: Z3_context): cuint {.importc: "Z3_get_num_scopes", dynlib: libz3.} 596 | proc Z3_persist_ast*(c: Z3_context,a: Z3_ast,num_scopes: cuint) {.importc: "Z3_persist_ast", dynlib: libz3.} 597 | proc Z3_assert_cnstr*(c: Z3_context,a: Z3_ast) {.importc: "Z3_assert_cnstr", dynlib: libz3.} 598 | proc Z3_check_and_get_model*(c: Z3_context,m: ptr Z3_model): Z3_lbool {.importc: "Z3_check_and_get_model", dynlib: libz3.} 599 | proc Z3_check*(c: Z3_context): Z3_lbool {.importc: "Z3_check", dynlib: libz3.} 600 | proc Z3_del_model*(c: Z3_context,m: Z3_model) {.importc: "Z3_del_model", dynlib: libz3.} 601 | proc Z3_soft_check_cancel*(c: Z3_context) {.importc: "Z3_soft_check_cancel", dynlib: libz3.} 602 | proc Z3_get_search_failure*(c: Z3_context): Z3_search_failure {.importc: "Z3_get_search_failure", dynlib: libz3.} 603 | proc Z3_mk_label*(c: Z3_context,s: Z3_symbol,is_pos: Z3_bool,f: Z3_ast): Z3_ast {.importc: "Z3_mk_label", dynlib: libz3.} 604 | proc Z3_get_relevant_labels*(c: Z3_context): Z3_literals {.importc: "Z3_get_relevant_labels", dynlib: libz3.} 605 | proc Z3_get_relevant_literals*(c: Z3_context): Z3_literals {.importc: "Z3_get_relevant_literals", dynlib: libz3.} 606 | proc Z3_get_guessed_literals*(c: Z3_context): Z3_literals {.importc: "Z3_get_guessed_literals", dynlib: libz3.} 607 | proc Z3_del_literals*(c: Z3_context,lbls: Z3_literals) {.importc: "Z3_del_literals", dynlib: libz3.} 608 | proc Z3_get_num_literals*(c: Z3_context,lbls: Z3_literals): cuint {.importc: "Z3_get_num_literals", dynlib: libz3.} 609 | proc Z3_get_label_symbol*(c: Z3_context,lbls: Z3_literals,idx: cuint): Z3_symbol {.importc: "Z3_get_label_symbol", dynlib: libz3.} 610 | proc Z3_get_literal*(c: Z3_context,lbls: Z3_literals,idx: cuint): Z3_ast {.importc: "Z3_get_literal", dynlib: libz3.} 611 | proc Z3_disable_literal*(c: Z3_context,lbls: Z3_literals,idx: cuint) {.importc: "Z3_disable_literal", dynlib: libz3.} 612 | proc Z3_block_literals*(c: Z3_context,lbls: Z3_literals) {.importc: "Z3_block_literals", dynlib: libz3.} 613 | proc Z3_get_model_num_constants*(c: Z3_context,m: Z3_model): cuint {.importc: "Z3_get_model_num_constants", dynlib: libz3.} 614 | proc Z3_get_model_constant*(c: Z3_context,m: Z3_model,i: cuint): Z3_func_decl {.importc: "Z3_get_model_constant", dynlib: libz3.} 615 | proc Z3_get_model_num_funcs*(c: Z3_context,m: Z3_model): cuint {.importc: "Z3_get_model_num_funcs", dynlib: libz3.} 616 | proc Z3_get_model_func_decl*(c: Z3_context,m: Z3_model,i: cuint): Z3_func_decl {.importc: "Z3_get_model_func_decl", dynlib: libz3.} 617 | proc Z3_eval_func_decl*(c: Z3_context,m: Z3_model,decl: Z3_func_decl,v: ptr Z3_ast): Z3_bool {.importc: "Z3_eval_func_decl", dynlib: libz3.} 618 | proc Z3_is_array_value*(c: Z3_context,m: Z3_model,v: Z3_ast,num_entries: ptr cuint): Z3_bool {.importc: "Z3_is_array_value", dynlib: libz3.} 619 | proc Z3_get_model_func_else*(c: Z3_context,m: Z3_model,i: cuint): Z3_ast {.importc: "Z3_get_model_func_else", dynlib: libz3.} 620 | proc Z3_get_model_func_num_entries*(c: Z3_context,m: Z3_model,i: cuint): cuint {.importc: "Z3_get_model_func_num_entries", dynlib: libz3.} 621 | proc Z3_get_model_func_entry_num_args*(c: Z3_context,m: Z3_model,i: cuint,j: cuint): cuint {.importc: "Z3_get_model_func_entry_num_args", dynlib: libz3.} 622 | proc Z3_get_model_func_entry_arg*(c: Z3_context,m: Z3_model,i: cuint,j: cuint,k: cuint): Z3_ast {.importc: "Z3_get_model_func_entry_arg", dynlib: libz3.} 623 | proc Z3_get_model_func_entry_value*(c: Z3_context,m: Z3_model,i: cuint,j: cuint): Z3_ast {.importc: "Z3_get_model_func_entry_value", dynlib: libz3.} 624 | proc Z3_eval*(c: Z3_context,m: Z3_model,t: Z3_ast,v: ptr Z3_ast): Z3_bool {.importc: "Z3_eval", dynlib: libz3.} 625 | proc Z3_context_to_string*(c: Z3_context): Z3_string {.importc: "Z3_context_to_string", dynlib: libz3.} 626 | proc Z3_statistics_to_string*(c: Z3_context): Z3_string {.importc: "Z3_statistics_to_string", dynlib: libz3.} 627 | proc Z3_get_context_assignment*(c: Z3_context): Z3_ast {.importc: "Z3_get_context_assignment", dynlib: libz3.} 628 | proc Z3_algebraic_is_value*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_algebraic_is_value", dynlib: libz3.} 629 | proc Z3_algebraic_is_pos*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_algebraic_is_pos", dynlib: libz3.} 630 | proc Z3_algebraic_is_neg*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_algebraic_is_neg", dynlib: libz3.} 631 | proc Z3_algebraic_is_zero*(c: Z3_context,a: Z3_ast): Z3_bool {.importc: "Z3_algebraic_is_zero", dynlib: libz3.} 632 | proc Z3_algebraic_sign*(c: Z3_context,a: Z3_ast): cint {.importc: "Z3_algebraic_sign", dynlib: libz3.} 633 | proc Z3_algebraic_add*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_ast {.importc: "Z3_algebraic_add", dynlib: libz3.} 634 | proc Z3_algebraic_sub*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_ast {.importc: "Z3_algebraic_sub", dynlib: libz3.} 635 | proc Z3_algebraic_mul*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_ast {.importc: "Z3_algebraic_mul", dynlib: libz3.} 636 | proc Z3_algebraic_div*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_ast {.importc: "Z3_algebraic_div", dynlib: libz3.} 637 | proc Z3_algebraic_root*(c: Z3_context,a: Z3_ast,k: cuint): Z3_ast {.importc: "Z3_algebraic_root", dynlib: libz3.} 638 | proc Z3_algebraic_power*(c: Z3_context,a: Z3_ast,k: cuint): Z3_ast {.importc: "Z3_algebraic_power", dynlib: libz3.} 639 | proc Z3_algebraic_lt*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_lt", dynlib: libz3.} 640 | proc Z3_algebraic_gt*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_gt", dynlib: libz3.} 641 | proc Z3_algebraic_le*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_le", dynlib: libz3.} 642 | proc Z3_algebraic_ge*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_ge", dynlib: libz3.} 643 | proc Z3_algebraic_eq*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_eq", dynlib: libz3.} 644 | proc Z3_algebraic_neq*(c: Z3_context,a: Z3_ast,b: Z3_ast): Z3_bool {.importc: "Z3_algebraic_neq", dynlib: libz3.} 645 | proc Z3_polynomial_subresultants*(c: Z3_context,p: Z3_ast,q: Z3_ast,x: Z3_ast): Z3_ast_vector {.importc: "Z3_polynomial_subresultants", dynlib: libz3.} 646 | proc Z3_rcf_del*(c: Z3_context,a: Z3_rcf_num) {.importc: "Z3_rcf_del", dynlib: libz3.} 647 | proc Z3_rcf_mk_rational*(c: Z3_context,val: Z3_string): Z3_rcf_num {.importc: "Z3_rcf_mk_rational", dynlib: libz3.} 648 | proc Z3_rcf_mk_small_int*(c: Z3_context,val: cint): Z3_rcf_num {.importc: "Z3_rcf_mk_small_int", dynlib: libz3.} 649 | proc Z3_rcf_mk_pi*(c: Z3_context): Z3_rcf_num {.importc: "Z3_rcf_mk_pi", dynlib: libz3.} 650 | proc Z3_rcf_mk_e*(c: Z3_context): Z3_rcf_num {.importc: "Z3_rcf_mk_e", dynlib: libz3.} 651 | proc Z3_rcf_mk_infinitesimal*(c: Z3_context): Z3_rcf_num {.importc: "Z3_rcf_mk_infinitesimal", dynlib: libz3.} 652 | proc Z3_rcf_add*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_add", dynlib: libz3.} 653 | proc Z3_rcf_sub*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_sub", dynlib: libz3.} 654 | proc Z3_rcf_mul*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_mul", dynlib: libz3.} 655 | proc Z3_rcf_div*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_div", dynlib: libz3.} 656 | proc Z3_rcf_neg*(c: Z3_context,a: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_neg", dynlib: libz3.} 657 | proc Z3_rcf_inv*(c: Z3_context,a: Z3_rcf_num): Z3_rcf_num {.importc: "Z3_rcf_inv", dynlib: libz3.} 658 | proc Z3_rcf_power*(c: Z3_context,a: Z3_rcf_num,k: cuint): Z3_rcf_num {.importc: "Z3_rcf_power", dynlib: libz3.} 659 | proc Z3_rcf_lt*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_lt", dynlib: libz3.} 660 | proc Z3_rcf_gt*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_gt", dynlib: libz3.} 661 | proc Z3_rcf_le*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_le", dynlib: libz3.} 662 | proc Z3_rcf_ge*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_ge", dynlib: libz3.} 663 | proc Z3_rcf_eq*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_eq", dynlib: libz3.} 664 | proc Z3_rcf_neq*(c: Z3_context,a: Z3_rcf_num,b: Z3_rcf_num): Z3_bool {.importc: "Z3_rcf_neq", dynlib: libz3.} 665 | proc Z3_rcf_num_to_string*(c: Z3_context,a: Z3_rcf_num,compact: Z3_bool,html: Z3_bool): Z3_string {.importc: "Z3_rcf_num_to_string", dynlib: libz3.} 666 | proc Z3_rcf_num_to_decimal_string*(c: Z3_context,a: Z3_rcf_num,prec: cuint): Z3_string {.importc: "Z3_rcf_num_to_decimal_string", dynlib: libz3.} 667 | proc Z3_rcf_get_numerator_denominator*(c: Z3_context,a: Z3_rcf_num,n: ptr Z3_rcf_num,d: ptr Z3_rcf_num) {.importc: "Z3_rcf_get_numerator_denominator", dynlib: libz3.} 668 | proc Z3_mk_interpolant*(c: Z3_context,a: Z3_ast): Z3_ast {.importc: "Z3_mk_interpolant", dynlib: libz3.} 669 | proc Z3_mk_interpolation_context*(cfg: Z3_config): Z3_context {.importc: "Z3_mk_interpolation_context", dynlib: libz3.} 670 | proc Z3_get_interpolant*(c: Z3_context,pf: Z3_ast,pat: Z3_ast,p: Z3_params): Z3_ast_vector {.importc: "Z3_get_interpolant", dynlib: libz3.} 671 | proc Z3_compute_interpolant*(c: Z3_context,pat: Z3_ast,p: Z3_params,interp: ptr Z3_ast_vector,model: ptr Z3_model): Z3_lbool {.importc: "Z3_compute_interpolant", dynlib: libz3.} 672 | proc Z3_interpolation_profile*(ctx: Z3_context): Z3_string {.importc: "Z3_interpolation_profile", dynlib: libz3.} 673 | proc Z3_mk_fpa_rounding_mode_sort*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_rounding_mode_sort", dynlib: libz3.} 674 | proc Z3_mk_fpa_round_nearest_ties_to_even*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_round_nearest_ties_to_even", dynlib: libz3.} 675 | proc Z3_mk_fpa_rne*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_rne", dynlib: libz3.} 676 | proc Z3_mk_fpa_round_nearest_ties_to_away*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_round_nearest_ties_to_away", dynlib: libz3.} 677 | proc Z3_mk_fpa_rna*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_rna", dynlib: libz3.} 678 | proc Z3_mk_fpa_round_toward_positive*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_round_toward_positive", dynlib: libz3.} 679 | proc Z3_mk_fpa_rtp*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_rtp", dynlib: libz3.} 680 | proc Z3_mk_fpa_round_toward_negative*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_round_toward_negative", dynlib: libz3.} 681 | proc Z3_mk_fpa_rtn*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_rtn", dynlib: libz3.} 682 | proc Z3_mk_fpa_round_toward_zero*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_round_toward_zero", dynlib: libz3.} 683 | proc Z3_mk_fpa_rtz*(c: Z3_context): Z3_ast {.importc: "Z3_mk_fpa_rtz", dynlib: libz3.} 684 | proc Z3_mk_fpa_sort*(c: Z3_context,ebits: cuint,sbits: cuint): Z3_sort {.importc: "Z3_mk_fpa_sort", dynlib: libz3.} 685 | proc Z3_mk_fpa_sort_half*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_half", dynlib: libz3.} 686 | proc Z3_mk_fpa_sort_16*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_16", dynlib: libz3.} 687 | proc Z3_mk_fpa_sort_single*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_single", dynlib: libz3.} 688 | proc Z3_mk_fpa_sort_32*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_32", dynlib: libz3.} 689 | proc Z3_mk_fpa_sort_double*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_double", dynlib: libz3.} 690 | proc Z3_mk_fpa_sort_64*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_64", dynlib: libz3.} 691 | proc Z3_mk_fpa_sort_quadruple*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_quadruple", dynlib: libz3.} 692 | proc Z3_mk_fpa_sort_128*(c: Z3_context): Z3_sort {.importc: "Z3_mk_fpa_sort_128", dynlib: libz3.} 693 | proc Z3_mk_fpa_nan*(c: Z3_context,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_nan", dynlib: libz3.} 694 | proc Z3_mk_fpa_inf*(c: Z3_context,s: Z3_sort,negative: Z3_bool): Z3_ast {.importc: "Z3_mk_fpa_inf", dynlib: libz3.} 695 | proc Z3_mk_fpa_zero*(c: Z3_context,s: Z3_sort,negative: Z3_bool): Z3_ast {.importc: "Z3_mk_fpa_zero", dynlib: libz3.} 696 | proc Z3_mk_fpa_fp*(c: Z3_context,sgn: Z3_ast,exp: Z3_ast,sig: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_fp", dynlib: libz3.} 697 | proc Z3_mk_fpa_numeral_float*(c: Z3_context,v: cfloat,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_numeral_float", dynlib: libz3.} 698 | proc Z3_mk_fpa_numeral_double*(c: Z3_context,v: cdouble,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_numeral_double", dynlib: libz3.} 699 | proc Z3_mk_fpa_numeral_int*(c: Z3_context,v: cint,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_numeral_int", dynlib: libz3.} 700 | proc Z3_mk_fpa_numeral_int_uint*(c: Z3_context,sgn: Z3_bool,exp: cint,sig: cuint,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_numeral_int_uint", dynlib: libz3.} 701 | proc Z3_mk_fpa_numeral_int64_uint64*(c: Z3_context,sgn: Z3_bool,exp: clonglong,sig: culonglong,ty: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_numeral_int64_uint64", dynlib: libz3.} 702 | proc Z3_mk_fpa_abs*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_abs", dynlib: libz3.} 703 | proc Z3_mk_fpa_neg*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_neg", dynlib: libz3.} 704 | proc Z3_mk_fpa_add*(c: Z3_context,rm: Z3_ast,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_add", dynlib: libz3.} 705 | proc Z3_mk_fpa_sub*(c: Z3_context,rm: Z3_ast,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_sub", dynlib: libz3.} 706 | proc Z3_mk_fpa_mul*(c: Z3_context,rm: Z3_ast,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_mul", dynlib: libz3.} 707 | proc Z3_mk_fpa_div*(c: Z3_context,rm: Z3_ast,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_div", dynlib: libz3.} 708 | proc Z3_mk_fpa_fma*(c: Z3_context,rm: Z3_ast,t1: Z3_ast,t2: Z3_ast,t3: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_fma", dynlib: libz3.} 709 | proc Z3_mk_fpa_sqrt*(c: Z3_context,rm: Z3_ast,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_sqrt", dynlib: libz3.} 710 | proc Z3_mk_fpa_rem*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_rem", dynlib: libz3.} 711 | proc Z3_mk_fpa_round_to_integral*(c: Z3_context,rm: Z3_ast,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_round_to_integral", dynlib: libz3.} 712 | proc Z3_mk_fpa_min*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_min", dynlib: libz3.} 713 | proc Z3_mk_fpa_max*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_max", dynlib: libz3.} 714 | proc Z3_mk_fpa_leq*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_leq", dynlib: libz3.} 715 | proc Z3_mk_fpa_lt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_lt", dynlib: libz3.} 716 | proc Z3_mk_fpa_geq*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_geq", dynlib: libz3.} 717 | proc Z3_mk_fpa_gt*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_gt", dynlib: libz3.} 718 | proc Z3_mk_fpa_eq*(c: Z3_context,t1: Z3_ast,t2: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_eq", dynlib: libz3.} 719 | proc Z3_mk_fpa_is_normal*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_normal", dynlib: libz3.} 720 | proc Z3_mk_fpa_is_subnormal*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_subnormal", dynlib: libz3.} 721 | proc Z3_mk_fpa_is_zero*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_zero", dynlib: libz3.} 722 | proc Z3_mk_fpa_is_infinite*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_infinite", dynlib: libz3.} 723 | proc Z3_mk_fpa_is_nan*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_nan", dynlib: libz3.} 724 | proc Z3_mk_fpa_is_negative*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_negative", dynlib: libz3.} 725 | proc Z3_mk_fpa_is_positive*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_is_positive", dynlib: libz3.} 726 | proc Z3_mk_fpa_to_fp_bv*(c: Z3_context,bv: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_bv", dynlib: libz3.} 727 | proc Z3_mk_fpa_to_fp_float*(c: Z3_context,rm: Z3_ast,t: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_float", dynlib: libz3.} 728 | proc Z3_mk_fpa_to_fp_real*(c: Z3_context,rm: Z3_ast,t: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_real", dynlib: libz3.} 729 | proc Z3_mk_fpa_to_fp_signed*(c: Z3_context,rm: Z3_ast,t: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_signed", dynlib: libz3.} 730 | proc Z3_mk_fpa_to_fp_unsigned*(c: Z3_context,rm: Z3_ast,t: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_unsigned", dynlib: libz3.} 731 | proc Z3_mk_fpa_to_ubv*(c: Z3_context,rm: Z3_ast,t: Z3_ast,sz: cuint): Z3_ast {.importc: "Z3_mk_fpa_to_ubv", dynlib: libz3.} 732 | proc Z3_mk_fpa_to_sbv*(c: Z3_context,rm: Z3_ast,t: Z3_ast,sz: cuint): Z3_ast {.importc: "Z3_mk_fpa_to_sbv", dynlib: libz3.} 733 | proc Z3_mk_fpa_to_real*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_to_real", dynlib: libz3.} 734 | proc Z3_fpa_get_ebits*(c: Z3_context,s: Z3_sort): cuint {.importc: "Z3_fpa_get_ebits", dynlib: libz3.} 735 | proc Z3_fpa_get_sbits*(c: Z3_context,s: Z3_sort): cuint {.importc: "Z3_fpa_get_sbits", dynlib: libz3.} 736 | proc Z3_fpa_get_numeral_sign*(c: Z3_context,t: Z3_ast,sgn: ptr cint): Z3_bool {.importc: "Z3_fpa_get_numeral_sign", dynlib: libz3.} 737 | proc Z3_fpa_get_numeral_significand_string*(c: Z3_context,t: Z3_ast): Z3_string {.importc: "Z3_fpa_get_numeral_significand_string", dynlib: libz3.} 738 | proc Z3_fpa_get_numeral_significand_uint64*(c: Z3_context,t: Z3_ast,n: ptr culonglong): Z3_bool {.importc: "Z3_fpa_get_numeral_significand_uint64", dynlib: libz3.} 739 | proc Z3_fpa_get_numeral_exponent_string*(c: Z3_context,t: Z3_ast): Z3_string {.importc: "Z3_fpa_get_numeral_exponent_string", dynlib: libz3.} 740 | proc Z3_fpa_get_numeral_exponent_int64*(c: Z3_context,t: Z3_ast,n: ptr clonglong): Z3_bool {.importc: "Z3_fpa_get_numeral_exponent_int64", dynlib: libz3.} 741 | proc Z3_mk_fpa_to_ieee_bv*(c: Z3_context,t: Z3_ast): Z3_ast {.importc: "Z3_mk_fpa_to_ieee_bv", dynlib: libz3.} 742 | proc Z3_mk_fpa_to_fp_int_real*(c: Z3_context,rm: Z3_ast,exp: Z3_ast,sig: Z3_ast,s: Z3_sort): Z3_ast {.importc: "Z3_mk_fpa_to_fp_int_real", dynlib: libz3.} 743 | proc Z3_mk_exists_const*(c: Z3_context, weight: cuint, num_bound: cuint, bound: ptr Z3_app, num_patterns: cuint, patterns: ptr Z3_pattern, body: Z3_ast): Z3_ast {.importc: "Z3_mk_exists_const", dynlib: libz3.} 744 | proc Z3_mk_forall_const*(c: Z3_context, weight: cuint, num_bound: cuint, bound: ptr Z3_app, num_patterns: cuint, patterns: ptr Z3_pattern, body: Z3_ast): Z3_ast {.importc: "Z3_mk_forall_const", dynlib: libz3.} 745 | proc Z3_mk_pattern*(c: Z3_context, num_patterns: cuint, terms: ptr Z3_ast): Z3_pattern {.importc: "Z3_mk_pattern", dynlib: libz3.} 746 | --------------------------------------------------------------------------------