Refactor CLI to support new ProofSystem API

2025-09-23 12:18:44 +00:00 · 2019-11-11 14:47:34 +01:00 · 2019-11-11 14:47:34 +01:00 · c39dd0ea22
commit c39dd0ea22
parent 97f9cc6e2b
165 changed files with 3204 additions and 0 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -8,6 +8,14 @@ dependencies = [
 "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "approx"
 version = "0.1.1"
@ -34,6 +42,15 @@ dependencies = [
 "skeptic 0.13.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "atty"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.65 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "autocfg"
 version = "0.1.7"
@ -208,6 +225,20 @@ dependencies = [
 "rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "clap"
+version = "2.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "cmake"
 version = "0.1.42"
@ -1187,6 +1218,11 @@ name = "sourcefile"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "syn"
 version = "0.14.9"
@ -1250,6 +1286,14 @@ dependencies = [
 "winapi 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "thread_local"
 version = "0.3.6"
@ -1317,6 +1361,11 @@ name = "unicode-segmentation"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "unicode-width"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "unicode-xid"
 version = "0.1.0"
@ -1347,6 +1396,11 @@ name = "vcpkg"
 version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "vec_map"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "version_check"
 version = "0.1.5"
@ -1523,6 +1577,24 @@ dependencies = [
 "zokrates_field 0.3.4",
 ]

+[[package]]
+name = "zokrates_cli"
+version = "0.5.0"
+dependencies = [
+ "assert_cli 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fs_extra 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zokrates_abi 0.1.0",
+ "zokrates_core 0.4.0",
+ "zokrates_field 0.3.4",
+ "zokrates_fs_resolver 0.4.2",
+]
+
 [[package]]
 name = "zokrates_core"
 version = "0.4.0"
@ -1642,9 +1714,11 @@ dependencies = [

 [metadata]
 "checksum aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
+"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
 "checksum approx 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "08abcc3b4e9339e33a3d0a5ed15d84a687350c05689d825e0f6655eef9e76a94"
 "checksum arrayvec 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9"
 "checksum assert_cli 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)" = "72342c21057a3cb5f7c2d849bf7999a83795434dd36d74fa8c24680581bd1930"
+"checksum atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1803c647a3ec87095e7ae7acfca019e98de5ec9a7d01343f611cf3152ed71a90"
 "checksum autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
 "checksum backtrace 0.3.40 (registry+https://github.com/rust-lang/crates.io-index)" = "924c76597f0d9ca25d762c25a4d369d51267536465dc5064bdf0eb073ed477ea"
 "checksum backtrace-sys 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491"
@ -1666,6 +1740,7 @@ dependencies = [
 "checksum cc 1.0.46 (registry+https://github.com/rust-lang/crates.io-index)" = "0213d356d3c4ea2c18c40b037c3be23cd639825c18f25ee670ac7813beeef99c"
 "checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 "checksum cgmath 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)" = "64a4b57c8f4e3a2e9ac07e0f6abc9c24b6fc9e1b54c3478cfb598f3d0023e51c"
+"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
 "checksum cmake 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "81fb25b677f8bf1eb325017cb6bb8452f87969db0fedb4f757b297bee78a7c62"
 "checksum colored 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6cdb90b60f2927f8d76139c72dbde7e10c3a2bc47c8594c9c7a66529f2687c03"
 "checksum constant_time_eq 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "995a44c877f9212528ccc74b21a232f66ad69001e40ede5bcee2ac9ef2657120"
@ -1786,12 +1861,14 @@ dependencies = [
 "checksum skeptic 0.13.4 (registry+https://github.com/rust-lang/crates.io-index)" = "d6fb8ed853fdc19ce09752d63f3a2e5b5158aeb261520cd75eb618bd60305165"
 "checksum smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "ab606a9c5e214920bb66c458cd7be8ef094f813f20fe77a54cc7dbfff220d4b7"
 "checksum sourcefile 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4bf77cb82ba8453b42b6ae1d692e4cdc92f9a47beaf89a847c8be83f4e328ad3"
+"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 "checksum syn 0.14.9 (registry+https://github.com/rust-lang/crates.io-index)" = "261ae9ecaa397c42b960649561949d69311f08eeaea86a65696e6e46517cf741"
 "checksum syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)" = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5"
 "checksum syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "66850e97125af79138385e9b88339cbcd037e3f28ceab8c5ad98e64f0f1f80bf"
 "checksum synstructure 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3f085a5855930c0441ca1288cf044ea4aecf4f43a91668abdb870b4ba546a203"
 "checksum tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
 "checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
+"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
 "checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
 "checksum tiny-keccak 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8a021c69bb74a44ccedb824a046447e2c84a01df9e5c20779750acb38e11b2"
@ -1802,11 +1879,13 @@ dependencies = [
 "checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
 "checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
 "checksum unicode-segmentation 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1967f4cdfc355b37fd76d2a954fb2ed3871034eb4f26d60537d88795cfc332a9"
+"checksum unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7007dbd421b92cc6e28410fe7362e2e0a2503394908f417b68ec8d1c364c4e20"
 "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
 "checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
 "checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
 "checksum utf8-ranges 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b4ae116fef2b7fea257ed6440d3cfcff7f190865f170cdad00bb6465bf18ecba"
 "checksum vcpkg 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "33dd455d0f96e90a75803cfeb7f948768c08d70a6de9a8d2362461935698bf95"
+"checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
 "checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
 "checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
 "checksum walkdir 2.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9658c94fa8b940eab2250bd5a457f9c48b748420d71293b165c8cdbe2f55f71e"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -2,6 +2,8 @@

 members = [
    "zokrates_core",
+    "zokrates_cli",
+    "zokrates_fs_resolver",
    "zokrates_stdlib",
    "zokrates_embed",
    "zokrates_abi",
--- a/zokrates_cli/Cargo.toml
+++ b/zokrates_cli/Cargo.toml
@ -0,0 +1,32 @@
+[package]
+name = "zokrates_cli"
+version = "0.5.0"
+authors = ["Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>", "Dennis Kuhnert <mail@kyroy.com>", "Thibaut Schaeffer <thibaut@schaeff.fr>"]
+repository = "https://github.com/JacobEberhardt/ZoKrates.git"
+edition = "2018"
+
+[features]
+default = ["libsnark"]
+libsnark = ["zokrates_core/libsnark"]
+
+[dependencies]
+clap = "2.26.2"
+bincode = "0.8.0"
+regex = "0.2"
+zokrates_field = { version = "0.3", path = "../zokrates_field" }
+zokrates_abi = { version = "0.1", path = "../zokrates_abi" }
+zokrates_core = { version = "0.4", path = "../zokrates_core" }
+zokrates_fs_resolver = { version = "0.4", path = "../zokrates_fs_resolver"}
+serde_json = "1.0"
+
+[dev-dependencies]
+glob = "0.2.11"
+assert_cli = "0.5"
+tempdir = "0.3"
+
+[build-dependencies]
+fs_extra = "1.1.0"
+
+[[bin]]
+name = "zokrates"
+path = "src/bin.rs"
--- a/zokrates_cli/build.rs
+++ b/zokrates_cli/build.rs
@ -0,0 +1,15 @@
+use fs_extra::copy_items;
+use fs_extra::dir::CopyOptions;
+use std::env;
+
+fn main() {
+    // export js test folder to OUT_DIR
+    export_stdlib();
+}
+
+fn export_stdlib() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let mut options = CopyOptions::new();
+    options.overwrite = true;
+    copy_items(&vec!["tests/contract"], out_dir, &options).unwrap();
+}
--- a/zokrates_cli/examples/add.zok
+++ b/zokrates_cli/examples/add.zok
@ -0,0 +1,6 @@
+// only using add, no need to flatten
+def main(field a) -> (field):
+  field b = a + 5
+  field c = a + b + a + 4
+  field d = a + c + a + b
+  return b + c + d
--- a/zokrates_cli/examples/argument_reassign.zok
+++ b/zokrates_cli/examples/argument_reassign.zok
@ -0,0 +1,6 @@
+def sub(field a) -> (field):
+  a = a + 3
+  return a
+
+def main() -> (field):
+   return sub(4)
--- a/zokrates_cli/examples/arrays/array_argument.zok
+++ b/zokrates_cli/examples/arrays/array_argument.zok
@ -0,0 +1,2 @@
+def main(field[3] a) -> (field):
+	return a[0] + a[1] + a[2]
--- a/zokrates_cli/examples/arrays/array_loop.zok
+++ b/zokrates_cli/examples/arrays/array_loop.zok
@ -0,0 +1,7 @@
+def main() -> (field):
+	field[3] a = [1, 2, 3]
+	field c = 0
+	for field i in 0..3 do
+		c = c + a[i]
+	endfor
+	return c
--- a/zokrates_cli/examples/arrays/array_loop_update.zok
+++ b/zokrates_cli/examples/arrays/array_loop_update.zok
@ -0,0 +1,7 @@
+def main() -> (field[3]):
+	field[3] a = [1, 2, 3]
+	field[3] c = [4, 5, 6]
+	for field i in 0..3 do
+		c[i] = c[i] + a[i]
+	endfor
+	return c
--- a/zokrates_cli/examples/arrays/boolean_array.zok
+++ b/zokrates_cli/examples/arrays/boolean_array.zok
@ -0,0 +1,9 @@
+def main(bool[3] a) -> (field[3]):
+	bool[3] c = [true, true || false, true]
+	a[1] = true || a[2]
+	a[2] = a[0]
+	field[3] result = [0; 3]
+	for field i in 0..3 do
+		result[i] = if a[i] then 33 else 0 fi
+	endfor
+	return result
--- a/zokrates_cli/examples/arrays/constant_array.zok
+++ b/zokrates_cli/examples/arrays/constant_array.zok
@ -0,0 +1,3 @@
+def main() -> (field):
+	field[4] a = [1, 2, 42, 55]
+	return a[2]
--- a/zokrates_cli/examples/arrays/cube.zok
+++ b/zokrates_cli/examples/arrays/cube.zok
@ -0,0 +1,12 @@
+def main(field[2][2][2] cube) -> (field):
+	field res = 0
+
+	for field i in 0..2 do
+		for field j in 0..2 do
+			for field k in 0..2 do
+				res = res + cube[i][j][k]
+			endfor
+		endfor
+	endfor
+
+	return res
--- a/zokrates_cli/examples/arrays/if_eq.zok
+++ b/zokrates_cli/examples/arrays/if_eq.zok
@ -0,0 +1,2 @@
+def main(field[2] a, field[2] b, field condition) -> (field[2]):
+	return if condition == 1 then a else b fi
--- a/zokrates_cli/examples/arrays/init_with_value.zok
+++ b/zokrates_cli/examples/arrays/init_with_value.zok
@ -0,0 +1,2 @@
+def main(field value) -> (field[3]):
+  return [value, value, value]
--- a/zokrates_cli/examples/arrays/lookup.zok
+++ b/zokrates_cli/examples/arrays/lookup.zok
@ -0,0 +1,2 @@
+def main(field index, field[5] array) -> (field):
+	return array[index]
--- a/zokrates_cli/examples/arrays/multidim_update.zok
+++ b/zokrates_cli/examples/arrays/multidim_update.zok
@ -0,0 +1,4 @@
+def main(field[10][10][10] a, field i, field j, field k) -> (field[3]):
+	a[i][j][k] = 42
+	field[3][3] b = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
+	return b[0]
--- a/zokrates_cli/examples/arrays/return_array.zok
+++ b/zokrates_cli/examples/arrays/return_array.zok
@ -0,0 +1,5 @@
+def foo() -> (field[2]):
+	return [1, 2]
+
+def main() -> (field[2]):
+	return foo()
--- a/zokrates_cli/examples/arrays/return_variable_array.zok
+++ b/zokrates_cli/examples/arrays/return_variable_array.zok
@ -0,0 +1,2 @@
+def main(field[2] a, field[2] b) -> (field[2]):
+	return [a[0] + b[0], a[1] + b[1]]
--- a/zokrates_cli/examples/arrays/slicefrom.zok
+++ b/zokrates_cli/examples/arrays/slicefrom.zok
--- a/zokrates_cli/examples/arrays/update.zok
+++ b/zokrates_cli/examples/arrays/update.zok
@ -0,0 +1,9 @@
+def foo(field[3] a) -> (field):
+	a[1] = 2
+	return a[1]
+
+def main() -> (field, field):
+	field[3] a = [0, 0, 0]
+	res = foo(a)
+	a[1] == 0
+	return res, a[1]
--- a/zokrates_cli/examples/arrays/update_with_call.zok
+++ b/zokrates_cli/examples/arrays/update_with_call.zok
@ -0,0 +1,9 @@
+def foo(field a) -> (field):
+	return 2
+
+def main(field a) -> (field, field):
+	field[2] result = [0, 0]
+	field r = foo(a)
+	result[1] = r
+	result[1] == r
+	return result[1], r
--- a/zokrates_cli/examples/arrays/value.zok
+++ b/zokrates_cli/examples/arrays/value.zok
@ -0,0 +1,10 @@
+def main() -> ():
+	field[3] a = [1, 2, 3]
+	bool[3] b = [true, true, false]
+	field[3][2] c = [[1, 2], [3, 4], [5, 6]]
+
+	field[3] aa = [...a]
+	bool[3] bb = [...b]
+	field[3][2] cc = [...c]
+
+	return
--- a/zokrates_cli/examples/arrays/wrap_select.zok
+++ b/zokrates_cli/examples/arrays/wrap_select.zok
@ -0,0 +1,7 @@
+def get(field[32] array, field index) -> (field):
+	return array[index]
+
+def main() -> (field):
+	field[32] array = [0, 0, 0, 0, 0, 0, 7, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+	field r = get(array, 7)
+	return r
--- a/zokrates_cli/examples/book/array.zok
+++ b/zokrates_cli/examples/book/array.zok
@ -0,0 +1,8 @@
+def main() -> (field):
+    field[3] a = [1, 2, 3] // initialize a field array with field values
+    a[2] = 4               // set a member to a value
+    field[4] b = [42; 4]   // initialize an array of 4 values all equal to 42
+    field[4] c = [...a, 4] // initialize an array copying values from `a`, followed by 4
+    field[2] d = a[1..3]   // initialize an array copying a slice from `a`
+    bool[3] e = [true, true || false, true] // initialize a boolean array
+    return a[0] + b[1] + c[2]
--- a/zokrates_cli/examples/book/comments.zok
+++ b/zokrates_cli/examples/book/comments.zok
@ -0,0 +1,4 @@
+def main() -> (field):
+    field a = 42 // this is an end of line comment
+    // this is a full line comment
+    return a
--- a/zokrates_cli/examples/book/factorize.zok
+++ b/zokrates_cli/examples/book/factorize.zok
@ -0,0 +1,3 @@
+def main(private field a, field b) -> (field):
+  field result = if a * a == b then 1 else 0 fi
+  return result
--- a/zokrates_cli/examples/book/field_overflow.zok
+++ b/zokrates_cli/examples/book/field_overflow.zok
@ -0,0 +1,4 @@
+def main() -> (field):
+    field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616
+    0 - 1 == pMinusOne
+    return 1
--- a/zokrates_cli/examples/book/for.zok
+++ b/zokrates_cli/examples/book/for.zok
@ -0,0 +1,6 @@
+def main() -> (field):
+    field res = 0
+    for field i in 0..4 do
+        res = res + i
+    endfor
+    return res
--- a/zokrates_cli/examples/book/for_scope.zok
+++ b/zokrates_cli/examples/book/for_scope.zok
@ -0,0 +1,7 @@
+def main() -> (field):
+	field a = 0
+	for field i in 0..5 do
+		a = a + i
+	endfor
+	// return i <- not allowed
+	return a
--- a/zokrates_cli/examples/book/function_declaration.zok
+++ b/zokrates_cli/examples/book/function_declaration.zok
@ -0,0 +1,5 @@
+def foo() -> (field):
+    return 1
+
+def main() -> (field):
+    return foo()
--- a/zokrates_cli/examples/book/function_scope.zok
+++ b/zokrates_cli/examples/book/function_scope.zok
@ -0,0 +1,7 @@
+def foo() -> (field):
+	// return myGlobal <- not allowed
+	return 42
+
+def main() -> (field):
+	field myGlobal = 42
+	return foo()
--- a/zokrates_cli/examples/book/hashexample.zok
+++ b/zokrates_cli/examples/book/hashexample.zok
@ -0,0 +1,5 @@
+import "hashes/sha256/512bitPacked" as sha256packed
+
+def main(private field a, private field b, private field c, private field d) -> (field[2]):
+	h = sha256packed([a, b, c, d])
+	return h
--- a/zokrates_cli/examples/book/hashexample_updated.zok
+++ b/zokrates_cli/examples/book/hashexample_updated.zok
@ -0,0 +1,7 @@
+import "hashes/sha256/512bitPacked" as sha256packed
+
+def main(private field a, private field b, private field c, private field d) -> (field):
+	h = sha256packed([a, b, c, d])
+	h[0] == 263561599766550617289250058199814760685
+	h[1] == 65303172752238645975888084098459749904
+	return 1
--- a/zokrates_cli/examples/book/if_else.zok
+++ b/zokrates_cli/examples/book/if_else.zok
@ -0,0 +1,3 @@
+def main(field x) -> (field):
+  field y = if x + 2 == 3 then 1 else 5 fi
+  return y
--- a/zokrates_cli/examples/book/multi_def.zok
+++ b/zokrates_cli/examples/book/multi_def.zok
@ -0,0 +1,6 @@
+def foo() -> (field, field):
+    return 21, 42
+
+def main() -> (field):
+    a, b = foo()
+    return 1
--- a/zokrates_cli/examples/book/multi_return.zok
+++ b/zokrates_cli/examples/book/multi_return.zok
@ -0,0 +1,2 @@
+def main() -> (field, field[3]):
+    return 1, [2, 3, 4]
--- a/zokrates_cli/examples/book/multidim_array.zok
+++ b/zokrates_cli/examples/book/multidim_array.zok
@ -0,0 +1,9 @@
+def main() -> (field):
+
+    // Array of two elements of array of 3 elements
+    field[2][3] a = [[1, 2, 3],[4, 5, 6]]
+
+    field[3] b = a[0] // should be [1, 2, 3]
+
+    // allowed access [0..2][0..3]
+    return a[1][2]
--- a/zokrates_cli/examples/book/no_shadowing.zok
+++ b/zokrates_cli/examples/book/no_shadowing.zok
@ -0,0 +1,7 @@
+def main() -> (field):
+	field a = 2
+	// field a = 3 <- not allowed
+	for field i in 0..5 do
+		// field a = 7 <- not allowed
+	endfor
+	return a
--- a/zokrates_cli/examples/book/side_effects.zok
+++ b/zokrates_cli/examples/book/side_effects.zok
@ -0,0 +1,9 @@
+def incr(field a) -> (field):
+    a = a + 1
+    return a
+
+def main() -> (field):
+    field x = 1
+    field res = incr(x)
+    x == 1 // x has not changed
+    return 1
--- a/zokrates_cli/examples/book/struct_assign.code
+++ b/zokrates_cli/examples/book/struct_assign.code
@ -0,0 +1,10 @@
+struct Point {
+	field x
+	field y
+}
+
+def main(field a) -> (Point):
+	Point p = Point {x: 1, y: 0}
+	p.x = a
+	p.y = p.x
+	return p
--- a/zokrates_cli/examples/book/struct_init.code
+++ b/zokrates_cli/examples/book/struct_init.code
@ -0,0 +1,8 @@
+struct Point {
+	field x
+	field y
+}
+
+def main() -> (Point):
+	Point p = Point {x: 1, y: 0}
+	return p
--- a/zokrates_cli/examples/book/structs.code
+++ b/zokrates_cli/examples/book/structs.code
@ -0,0 +1,14 @@
+struct Bar {
+	field[2] c
+	bool d
+}
+
+struct Foo {
+	Bar a
+	bool b 
+}
+
+def main() -> (Foo):
+	Foo[2] f = [Foo { a: Bar { c: [0, 0], d: false }, b: true}, Foo { a: Bar {c: [0, 0], d: false}, b: true}]
+	f[0].a.c = [42, 43]
+	return f[0]
--- a/zokrates_cli/examples/book/type_annotations.zok
+++ b/zokrates_cli/examples/book/type_annotations.zok
@ -0,0 +1,9 @@
+def foo() -> (field, field[3]):
+    return 1, [2, 3, 4]
+
+def foo() -> (field, field):
+    return 1, 2
+
+def main() -> (field):
+    a, field[3] b = foo()
+    return 1
--- a/zokrates_cli/examples/bool_and.zok
+++ b/zokrates_cli/examples/bool_and.zok
@ -0,0 +1,7 @@
+// example using if-then-else-fi with &&
+
+def main(field a, field b) -> (field):
+    field y = if a + 2 == 3 && a * 2 == 2 then 1 else 0 fi
+    field z = if y == 1 && 1-y == 0 then y else 1 fi
+    b == 1
+    return a
--- a/zokrates_cli/examples/bool_not.zok
+++ b/zokrates_cli/examples/bool_not.zok
@ -0,0 +1,3 @@
+def main(field a) -> (field):
+	field x = if !(!(a < 5) && !(a > 1) || a < 4) then 3 else 4 fi
+	return x
--- a/zokrates_cli/examples/bool_or.zok
+++ b/zokrates_cli/examples/bool_or.zok
@ -0,0 +1,7 @@
+// example using if-then-else-fi with ||
+def main(field a, field b) -> (field):
+    field y = if a + 2 == 4 || b * 2 == 2 then 1 else 0 fi
+    field z = if y == 1 || y == 0 then y else 1 fi
+    z == 1
+    return z 
+
--- a/zokrates_cli/examples/boolean_literal.zok
+++ b/zokrates_cli/examples/boolean_literal.zok
@ -0,0 +1,2 @@
+def main(bool a) -> (bool):
+	return (false || true) && false
--- a/zokrates_cli/examples/brackets.zok
+++ b/zokrates_cli/examples/brackets.zok
@ -0,0 +1,4 @@
+def main(field a) -> (field):
+  field b = (a + 5) * 6
+  field c = 7 * (b + a)
+  return b + c
--- a/zokrates_cli/examples/comments.zok
+++ b/zokrates_cli/examples/comments.zok
@ -0,0 +1,7 @@
+// only using add, no need to flatten
+def main(field a) -> (field): // a needs to be 1
+  field b = a + 5 // inline comment
+  field c = a + b + a + 4
+  a == 1 // another inline comment
+  field d = a + c + a + b
+  return b + c + d
--- a/zokrates_cli/examples/comparison_operators.zok
+++ b/zokrates_cli/examples/comparison_operators.zok
@ -0,0 +1,8 @@
+// comparison operator example
+def main(field x) -> (field):
+  field y = if x >= 3 then 1 else 5 fi
+  field z = if y <= x then x**3 else y**3 fi
+  y = if x < 3 then 2 else 6 fi
+  z = if y > z then 1 else 2 fi
+  x = if x == x then x else y fi
+  return x + y + z
--- a/zokrates_cli/examples/conditions.zok
+++ b/zokrates_cli/examples/conditions.zok
@ -0,0 +1,6 @@
+def main(field a) -> (field):
+  field b = (a + 5) * 6
+  2 * b == a * 12 + 60
+  field c = 7 * (b + a)
+  c == 7 * b + 7 * a
+  return b + c
--- a/zokrates_cli/examples/dex/decodeOrder.zok
+++ b/zokrates_cli/examples/dex/decodeOrder.zok
@ -0,0 +1,42 @@
+import "./popLeastSignificantBit"
+
+def main(field order) -> (field, field, field, field):
+  // MSB
+  // Limit price (120 bits - i.e. pow(10,36) in base 2)
+  // Target token (8 bits - i.e. we support 256 = 2^8 tokens)
+  // Source token (8 bits)
+  // Amount (120 bits)
+  // LSB
+  field amount = 0
+  field exponent = 1
+  for field i in 0..120 do
+    bit, order = popLeastSignificantBit(order)
+    amount = amount + (bit * exponent)
+    exponent = exponent * 2
+  endfor
+
+  field sourceToken = 0
+  exponent = 1
+  for field i in 0..5 do
+    bit, order = popLeastSignificantBit(order)
+    sourceToken = sourceToken + (bit * exponent)
+    exponent = exponent * 2
+  endfor
+
+  field targetToken = 0
+  exponent = 1
+  for field i in 0..5 do
+    bit, order = popLeastSignificantBit(order)
+    targetToken = targetToken + (bit * exponent)
+    exponent = exponent * 2
+  endfor
+
+  field limit = 0
+  exponent = 1
+  for field i in 0..120 do
+    bit, order = popLeastSignificantBit(order)
+    limit = limit + (bit * exponent)
+    exponent = exponent * 2
+  endfor
+
+  return amount, sourceToken, targetToken, limit
--- a/zokrates_cli/examples/dex/decodeOrderBitwise.zok
+++ b/zokrates_cli/examples/dex/decodeOrderBitwise.zok
@ -0,0 +1,252 @@
+def main(field bit0, field bit1, field bit2, field bit3, field bit4, field bit5, field bit6, field bit7, field bit8, field bit9, field bit10, field bit11, field bit12, field bit13, field bit14, field bit15, field bit16, field bit17, field bit18, field bit19, field bit20, field bit21, field bit22, field bit23, field bit24, field bit25, field bit26, field bit27, field bit28, field bit29, field bit30, field bit31, field bit32, field bit33, field bit34, field bit35, field bit36, field bit37, field bit38, field bit39, field bit40, field bit41, field bit42, field bit43, field bit44, field bit45, field bit46, field bit47, field bit48, field bit49, field bit50, field bit51, field bit52, field bit53, field bit54, field bit55, field bit56, field bit57, field bit58, field bit59, field bit60, field bit61, field bit62, field bit63, field bit64, field bit65, field bit66, field bit67, field bit68, field bit69, field bit70, field bit71, field bit72, field bit73, field bit74, field bit75, field bit76, field bit77, field bit78, field bit79, field bit80, field bit81, field bit82, field bit83, field bit84, field bit85, field bit86, field bit87, field bit88, field bit89, field bit90, field bit91, field bit92, field bit93, field bit94, field bit95, field bit96, field bit97, field bit98, field bit99, field bit100, field bit101, field bit102, field bit103, field bit104, field bit105, field bit106, field bit107, field bit108, field bit109, field bit110, field bit111, field bit112, field bit113, field bit114, field bit115, field bit116, field bit117, field bit118, field bit119, field bit120, field bit121, field bit122, field bit123, field bit124, field bit125, field bit126, field bit127, field bit128, field bit129, field bit130, field bit131, field bit132, field bit133, field bit134, field bit135, field bit136, field bit137, field bit138, field bit139, field bit140, field bit141, field bit142, field bit143, field bit144, field bit145, field bit146, field bit147, field bit148, field bit149, field bit150, field bit151, field bit152, field bit153, field bit154, field bit155, field bit156, field bit157, field bit158, field bit159, field bit160, field bit161, field bit162, field bit163, field bit164, field bit165, field bit166, field bit167, field bit168, field bit169, field bit170, field bit171, field bit172, field bit173, field bit174, field bit175, field bit176, field bit177, field bit178, field bit179, field bit180, field bit181, field bit182, field bit183, field bit184, field bit185, field bit186, field bit187, field bit188, field bit189, field bit190, field bit191, field bit192, field bit193, field bit194, field bit195, field bit196, field bit197, field bit198, field bit199, field bit200, field bit201, field bit202, field bit203, field bit204, field bit205, field bit206, field bit207, field bit208, field bit209, field bit210, field bit211, field bit212, field bit213, field bit214, field bit215, field bit216, field bit217, field bit218, field bit219, field bit220, field bit221, field bit222, field bit223, field bit224, field bit225, field bit226, field bit227, field bit228, field bit229, field bit230, field bit231, field bit232, field bit233, field bit234, field bit235, field bit236, field bit237, field bit238, field bit239, field bit240, field bit241, field bit242, field bit243, field bit244, field bit245, field bit246, field bit247, field bit248, field bit249, field bit250, field bit251, field bit252) -> (field, field, field, field):
+  field amount = bit0
+  amount = amount + (2 * bit1)
+  amount = amount + (4 * bit2)
+  amount = amount + (8 * bit3)
+  amount = amount + (16 * bit4)
+  amount = amount + (32 * bit5)
+  amount = amount + (64 * bit6)
+  amount = amount + (128 * bit7)
+  amount = amount + (256 * bit8)
+  amount = amount + (512 * bit9)
+  amount = amount + (1024 * bit10)
+  amount = amount + (2048 * bit11)
+  amount = amount + (4096 * bit12)
+  amount = amount + (8192 * bit13)
+  amount = amount + (16384 * bit14)
+  amount = amount + (32768 * bit15)
+  amount = amount + (65536 * bit16)
+  amount = amount + (131072 * bit17)
+  amount = amount + (262144 * bit18)
+  amount = amount + (524288 * bit19)
+  amount = amount + (1048576 * bit20)
+  amount = amount + (2097152 * bit21)
+  amount = amount + (4194304 * bit22)
+  amount = amount + (8388608 * bit23)
+  amount = amount + (16777216 * bit24)
+  amount = amount + (33554432 * bit25)
+  amount = amount + (67108864 * bit26)
+  amount = amount + (134217728 * bit27)
+  amount = amount + (268435456 * bit28)
+  amount = amount + (536870912 * bit29)
+  amount = amount + (1073741824 * bit30)
+  amount = amount + (2147483648 * bit31)
+  amount = amount + (4294967296 * bit32)
+  amount = amount + (8589934592 * bit33)
+  amount = amount + (17179869184 * bit34)
+  amount = amount + (34359738368 * bit35)
+  amount = amount + (68719476736 * bit36)
+  amount = amount + (137438953472 * bit37)
+  amount = amount + (274877906944 * bit38)
+  amount = amount + (549755813888 * bit39)
+  amount = amount + (1099511627776 * bit40)
+  amount = amount + (2199023255552 * bit41)
+  amount = amount + (4398046511104 * bit42)
+  amount = amount + (8796093022208 * bit43)
+  amount = amount + (17592186044416 * bit44)
+  amount = amount + (35184372088832 * bit45)
+  amount = amount + (70368744177664 * bit46)
+  amount = amount + (140737488355328 * bit47)
+  amount = amount + (281474976710656 * bit48)
+  amount = amount + (562949953421312 * bit49)
+  amount = amount + (1125899906842624 * bit50)
+  amount = amount + (2251799813685248 * bit51)
+  amount = amount + (4503599627370496 * bit52)
+  amount = amount + (9007199254740992 * bit53)
+  amount = amount + (18014398509481984 * bit54)
+  amount = amount + (36028797018963968 * bit55)
+  amount = amount + (72057594037927936 * bit56)
+  amount = amount + (144115188075855872 * bit57)
+  amount = amount + (288230376151711744 * bit58)
+  amount = amount + (576460752303423488 * bit59)
+  amount = amount + (1152921504606846976 * bit60)
+  amount = amount + (2305843009213693952 * bit61)
+  amount = amount + (4611686018427387904 * bit62)
+  amount = amount + (9223372036854775808 * bit63)
+  amount = amount + (18446744073709551616 * bit64)
+  amount = amount + (36893488147419103232 * bit65)
+  amount = amount + (73786976294838206464 * bit66)
+  amount = amount + (147573952589676412928 * bit67)
+  amount = amount + (295147905179352825856 * bit68)
+  amount = amount + (590295810358705651712 * bit69)
+  amount = amount + (1180591620717411303424 * bit70)
+  amount = amount + (2361183241434822606848 * bit71)
+  amount = amount + (4722366482869645213696 * bit72)
+  amount = amount + (9444732965739290427392 * bit73)
+  amount = amount + (18889465931478580854784 * bit74)
+  amount = amount + (37778931862957161709568 * bit75)
+  amount = amount + (75557863725914323419136 * bit76)
+  amount = amount + (151115727451828646838272 * bit77)
+  amount = amount + (302231454903657293676544 * bit78)
+  amount = amount + (604462909807314587353088 * bit79)
+  amount = amount + (1208925819614629174706176 * bit80)
+  amount = amount + (2417851639229258349412352 * bit81)
+  amount = amount + (4835703278458516698824704 * bit82)
+  amount = amount + (9671406556917033397649408 * bit83)
+  amount = amount + (19342813113834066795298816 * bit84)
+  amount = amount + (38685626227668133590597632 * bit85)
+  amount = amount + (77371252455336267181195264 * bit86)
+  amount = amount + (154742504910672534362390528 * bit87)
+  amount = amount + (309485009821345068724781056 * bit88)
+  amount = amount + (618970019642690137449562112 * bit89)
+  amount = amount + (1237940039285380274899124224 * bit90)
+  amount = amount + (2475880078570760549798248448 * bit91)
+  amount = amount + (4951760157141521099596496896 * bit92)
+  amount = amount + (9903520314283042199192993792 * bit93)
+  amount = amount + (19807040628566084398385987584 * bit94)
+  amount = amount + (39614081257132168796771975168 * bit95)
+  amount = amount + (79228162514264337593543950336 * bit96)
+  amount = amount + (158456325028528675187087900672 * bit97)
+  amount = amount + (316912650057057350374175801344 * bit98)
+  amount = amount + (633825300114114700748351602688 * bit99)
+  amount = amount + (1267650600228229401496703205376 * bit100)
+  amount = amount + (2535301200456458802993406410752 * bit101)
+  amount = amount + (5070602400912917605986812821504 * bit102)
+  amount = amount + (10141204801825835211973625643008 * bit103)
+  amount = amount + (20282409603651670423947251286016 * bit104)
+  amount = amount + (40564819207303340847894502572032 * bit105)
+  amount = amount + (81129638414606681695789005144064 * bit106)
+  amount = amount + (162259276829213363391578010288128 * bit107)
+  amount = amount + (324518553658426726783156020576256 * bit108)
+  amount = amount + (649037107316853453566312041152512 * bit109)
+  amount = amount + (1298074214633706907132624082305024 * bit110)
+  amount = amount + (2596148429267413814265248164610048 * bit111)
+  amount = amount + (5192296858534827628530496329220096 * bit112)
+  amount = amount + (10384593717069655257060992658440192 * bit113)
+  amount = amount + (20769187434139310514121985316880384 * bit114)
+  amount = amount + (41538374868278621028243970633760768 * bit115)
+  amount = amount + (83076749736557242056487941267521536 * bit116)
+  amount = amount + (166153499473114484112975882535043072 * bit117)
+  amount = amount + (332306998946228968225951765070086144 * bit118)
+  amount = amount + (664613997892457936451903530140172288 * bit119)
+  field sourceToken = bit120
+  sourceToken = sourceToken + (2 * bit121)
+  sourceToken = sourceToken + (4 * bit122)
+  sourceToken = sourceToken + (8 * bit123)
+  sourceToken = sourceToken + (16 * bit124)
+  field targetToken = bit125
+  targetToken = targetToken + (2 * bit126)
+  targetToken = targetToken + (4 * bit127)
+  targetToken = targetToken + (8 * bit128)
+  targetToken = targetToken + (16 * bit129)
+  field limit = bit130
+  limit = limit + (2 * bit131)
+  limit = limit + (4 * bit132)
+  limit = limit + (8 * bit133)
+  limit = limit + (16 * bit134)
+  limit = limit + (32 * bit135)
+  limit = limit + (64 * bit136)
+  limit = limit + (128 * bit137)
+  limit = limit + (256 * bit138)
+  limit = limit + (512 * bit139)
+  limit = limit + (1024 * bit140)
+  limit = limit + (2048 * bit141)
+  limit = limit + (4096 * bit142)
+  limit = limit + (8192 * bit143)
+  limit = limit + (16384 * bit144)
+  limit = limit + (32768 * bit145)
+  limit = limit + (65536 * bit146)
+  limit = limit + (131072 * bit147)
+  limit = limit + (262144 * bit148)
+  limit = limit + (524288 * bit149)
+  limit = limit + (1048576 * bit150)
+  limit = limit + (2097152 * bit151)
+  limit = limit + (4194304 * bit152)
+  limit = limit + (8388608 * bit153)
+  limit = limit + (16777216 * bit154)
+  limit = limit + (33554432 * bit155)
+  limit = limit + (67108864 * bit156)
+  limit = limit + (134217728 * bit157)
+  limit = limit + (268435456 * bit158)
+  limit = limit + (536870912 * bit159)
+  limit = limit + (1073741824 * bit160)
+  limit = limit + (2147483648 * bit161)
+  limit = limit + (4294967296 * bit162)
+  limit = limit + (8589934592 * bit163)
+  limit = limit + (17179869184 * bit164)
+  limit = limit + (34359738368 * bit165)
+  limit = limit + (68719476736 * bit166)
+  limit = limit + (137438953472 * bit167)
+  limit = limit + (274877906944 * bit168)
+  limit = limit + (549755813888 * bit169)
+  limit = limit + (1099511627776 * bit170)
+  limit = limit + (2199023255552 * bit171)
+  limit = limit + (4398046511104 * bit172)
+  limit = limit + (8796093022208 * bit173)
+  limit = limit + (17592186044416 * bit174)
+  limit = limit + (35184372088832 * bit175)
+  limit = limit + (70368744177664 * bit176)
+  limit = limit + (140737488355328 * bit177)
+  limit = limit + (281474976710656 * bit178)
+  limit = limit + (562949953421312 * bit179)
+  limit = limit + (1125899906842624 * bit180)
+  limit = limit + (2251799813685248 * bit181)
+  limit = limit + (4503599627370496 * bit182)
+  limit = limit + (9007199254740992 * bit183)
+  limit = limit + (18014398509481984 * bit184)
+  limit = limit + (36028797018963968 * bit185)
+  limit = limit + (72057594037927936 * bit186)
+  limit = limit + (144115188075855872 * bit187)
+  limit = limit + (288230376151711744 * bit188)
+  limit = limit + (576460752303423488 * bit189)
+  limit = limit + (1152921504606846976 * bit190)
+  limit = limit + (2305843009213693952 * bit191)
+  limit = limit + (4611686018427387904 * bit192)
+  limit = limit + (9223372036854775808 * bit193)
+  limit = limit + (18446744073709551616 * bit194)
+  limit = limit + (36893488147419103232 * bit195)
+  limit = limit + (73786976294838206464 * bit196)
+  limit = limit + (147573952589676412928 * bit197)
+  limit = limit + (295147905179352825856 * bit198)
+  limit = limit + (590295810358705651712 * bit199)
+  limit = limit + (1180591620717411303424 * bit200)
+  limit = limit + (2361183241434822606848 * bit201)
+  limit = limit + (4722366482869645213696 * bit202)
+  limit = limit + (9444732965739290427392 * bit203)
+  limit = limit + (18889465931478580854784 * bit204)
+  limit = limit + (37778931862957161709568 * bit205)
+  limit = limit + (75557863725914323419136 * bit206)
+  limit = limit + (151115727451828646838272 * bit207)
+  limit = limit + (302231454903657293676544 * bit208)
+  limit = limit + (604462909807314587353088 * bit209)
+  limit = limit + (1208925819614629174706176 * bit210)
+  limit = limit + (2417851639229258349412352 * bit211)
+  limit = limit + (4835703278458516698824704 * bit212)
+  limit = limit + (9671406556917033397649408 * bit213)
+  limit = limit + (19342813113834066795298816 * bit214)
+  limit = limit + (38685626227668133590597632 * bit215)
+  limit = limit + (77371252455336267181195264 * bit216)
+  limit = limit + (154742504910672534362390528 * bit217)
+  limit = limit + (309485009821345068724781056 * bit218)
+  limit = limit + (618970019642690137449562112 * bit219)
+  limit = limit + (1237940039285380274899124224 * bit220)
+  limit = limit + (2475880078570760549798248448 * bit221)
+  limit = limit + (4951760157141521099596496896 * bit222)
+  limit = limit + (9903520314283042199192993792 * bit223)
+  limit = limit + (19807040628566084398385987584 * bit224)
+  limit = limit + (39614081257132168796771975168 * bit225)
+  limit = limit + (79228162514264337593543950336 * bit226)
+  limit = limit + (158456325028528675187087900672 * bit227)
+  limit = limit + (316912650057057350374175801344 * bit228)
+  limit = limit + (633825300114114700748351602688 * bit229)
+  limit = limit + (1267650600228229401496703205376 * bit230)
+  limit = limit + (2535301200456458802993406410752 * bit231)
+  limit = limit + (5070602400912917605986812821504 * bit232)
+  limit = limit + (10141204801825835211973625643008 * bit233)
+  limit = limit + (20282409603651670423947251286016 * bit234)
+  limit = limit + (40564819207303340847894502572032 * bit235)
+  limit = limit + (81129638414606681695789005144064 * bit236)
+  limit = limit + (162259276829213363391578010288128 * bit237)
+  limit = limit + (324518553658426726783156020576256 * bit238)
+  limit = limit + (649037107316853453566312041152512 * bit239)
+  limit = limit + (1298074214633706907132624082305024 * bit240)
+  limit = limit + (2596148429267413814265248164610048 * bit241)
+  limit = limit + (5192296858534827628530496329220096 * bit242)
+  limit = limit + (10384593717069655257060992658440192 * bit243)
+  limit = limit + (20769187434139310514121985316880384 * bit244)
+  limit = limit + (41538374868278621028243970633760768 * bit245)
+  limit = limit + (83076749736557242056487941267521536 * bit246)
+  limit = limit + (166153499473114484112975882535043072 * bit247)
+  limit = limit + (332306998946228968225951765070086144 * bit248)
+  limit = limit + (664613997892457936451903530140172288 * bit249)
+  return amount, sourceToken, targetToken, limit
--- a/zokrates_cli/examples/dex/emptyOrder.zok
+++ b/zokrates_cli/examples/dex/emptyOrder.zok
@ -0,0 +1,2 @@
+def main() -> (field, field, field, field):
+  return 0, 0, 0, 0
--- a/zokrates_cli/examples/dex/isPartialOrder.zok
+++ b/zokrates_cli/examples/dex/isPartialOrder.zok
@ -0,0 +1,3 @@
+def main(field utxoAmount, field volume) -> (field):
+  field partial = if volume * (volume - utxoAmount) == 0 then 0 else 1 fi
+  return partial
--- a/zokrates_cli/examples/dex/limitLessThanPrice.zok
+++ b/zokrates_cli/examples/dex/limitLessThanPrice.zok
@ -0,0 +1,10 @@
+def main(field sourceTokenPrice, field targetTokenPrice, field limit) -> (field):
+  // Assuming limit is in sourceToken->targetToken and price_i in token_i->refToken
+  // Because of arbitrage freeness the following statement should hold:
+  // sourceToken->targetToken = sourceToken->refToken * refToken->targetToken = refToken->targetToken / refToken->sourceToken
+  // Therefore we have to check that:
+  // `limit <= sourceToken->refToken / targetToken->refToken`
+  // which is equivalent to checking
+  // `limit * targetToken->refToken <= sourceToken->refToken`
+  field limitIsLessOrEqual = if sourceTokenPrice * 1000000000000000000 < (limit * targetTokenPrice) then 0 else 1 fi
+  return limitIsLessOrEqual
--- a/zokrates_cli/examples/dex/popLeastSignificantBit.zok
+++ b/zokrates_cli/examples/dex/popLeastSignificantBit.zok
@ -0,0 +1,6 @@
+def main(field number) -> (field, field):
+  field bitModuloN = number / 2
+  // If number was even, bitModuloN < number
+  field bit = if number < bitModuloN then 1 else 0 fi
+  field remainder = if bit == 0 then number / 2 else (number - 1) / 2 fi
+  return bit, remainder
--- a/zokrates_cli/examples/dex/ringtrade_example.zok
+++ b/zokrates_cli/examples/dex/ringtrade_example.zok
@ -0,0 +1,99 @@
+import "./decodeOrder"
+import "./limitLessThanPrice"
+
+def tupleForTokensWithValue(field value) -> (field[3]):
+  return [value, value, value]
+
+def tupleForTokenPairsWithValue(field value) -> (field[9]):
+  return [value, value, value, value, value, value, value, value, value]
+
+def findPairInTokenPairList(field[9] pairs, field sourceToken, field targetToken) -> (field):
+  return pairs[sourceToken * 3 + targetToken]
+
+// add `volume` to element `token` in `volumeToken`
+def addVolumesForOrder(field[3] volumeToken, field token, field volume) -> (field[3]):
+  for field i in 0..3 do
+    volumeToken[i] = volumeToken[i] + if token == i then volume else 0 fi
+  endfor
+  return volumeToken
+
+def updateHighestTouchedOrder(field[9] highestTouchedOrder, field sourceToken, field targetToken, field limit, field volume) -> (field[9]):
+
+  field highest = findPairInTokenPairList(highestTouchedOrder, sourceToken, targetToken)
+
+  field shouldUpdate = if 0 < volume then 1 else 0 fi
+  shouldUpdate = if highest < limit then shouldUpdate else 0 fi
+
+  highestTouchedOrder[sourceToken * 3 + targetToken] = if shouldUpdate == 1 then limit else highestTouchedOrder[sourceToken * 3 + targetToken] fi
+
+  return highestTouchedOrder
+
+def verifyCompletelyFulfilledIfLimitLowerHighestTouchedOrder(field[9] highestTouchedOrder, field sourceAmount, field sourceToken, field targetToken, field limit, field volume) -> (field):
+
+  field highest = findPairInTokenPairList(highestTouchedOrder, sourceToken, targetToken)
+
+  field valid = if limit < highest then 1 - (sourceAmount - volume) else 1 fi
+  return valid
+
+def checkConstraints(field[3] amount, field[3] sourceToken, field[3] targetToken, field[3] limit, field[3] volume, field[3] priceToken) -> (field):
+  // volumes are not larger than in original offer
+  for field i in 0..3 do
+    1 == if amount[i] < volume[i] then 0 else 1 fi
+  endfor
+
+  field[3] sourceTokenPriceOrder = [0, 0, 0]
+  field[3] targetTokenPriceOrder = [0, 0, 0]
+  
+  for field i in 0..3 do
+    sourceTokenPriceOrder[i] = priceToken[sourceToken[i]]
+    targetTokenPriceOrder[i] = priceToken[targetToken[i]]
+  endfor
+
+  // orders are only touched, if the limit price is below the calculated price:
+  for field i in 0..3 do
+    1 == if volume[i] == 0 then 1 else limitLessThanPrice(sourceTokenPriceOrder[i], targetTokenPriceOrder[i], limit[i]) fi
+  endfor
+
+  // the amount of sell volume for a token equals its buy volume:
+  buyVolumeToken = tupleForTokensWithValue(0)
+  sellVolumeToken = tupleForTokensWithValue(0)
+
+  for field i in 0..3 do
+    buyVolumeToken = addVolumesForOrder(buyVolumeToken, targetToken[i], volume[i] * sourceTokenPriceOrder[i])
+    sellVolumeToken = addVolumesForOrder(sellVolumeToken, sourceToken[i], volume[i] * sourceTokenPriceOrder[i])
+  endfor
+
+  buyVolumeToken == sellVolumeToken
+
+  // If an order σ ∈ Oi→j with a limit price p has a positive trading volume, then every order in Oi→j with a lower limit price should be completely fulfilled.
+  highestTouchedOrder = tupleForTokenPairsWithValue(0)
+
+  for field i in 0..3 do 
+    highestTouchedOrder = updateHighestTouchedOrder(highestTouchedOrder, sourceToken[i], targetToken[i], limit[i], volume[i])
+  endfor
+
+  for field i in 0..3 do
+    1 == verifyCompletelyFulfilledIfLimitLowerHighestTouchedOrder(highestTouchedOrder, amount[i], sourceToken[i], targetToken[i], limit[i], volume[i])
+  endfor
+
+  return 1 // Could return total volume to maximize for
+
+def main(private field[3] encodedOrder, private field[3] bitmapOrder, private field[3] volume, private field[3] priceToken) -> (field):
+  // Remove orders that are not double signed
+  encodedOrder = [if bitmapOrder[0] == 1 then encodedOrder[0] else 0 fi, if bitmapOrder[1] == 1 then encodedOrder[1] else 0 fi, if bitmapOrder[2] == 1 then encodedOrder[2] else 0 fi]
+
+  field[3] amount = [0, 0, 0]
+  field[3] sourceToken = [0, 0, 0]
+  field[3] targetToken = [0, 0, 0]
+  field[3] limit = [0, 0, 0]
+
+  // Decode orders
+  for field i in 0..3 do 
+    a, s, t, l = decodeOrder(encodedOrder[i])
+    amount[i] = a
+    sourceToken[i] = s
+    targetToken[i] = t
+    limit[i] = l
+  endfor
+
+  return checkConstraints(amount, sourceToken, targetToken, limit, volume, priceToken)
--- a/zokrates_cli/examples/error/empty-error.zok
+++ b/zokrates_cli/examples/error/empty-error.zok
@ -0,0 +1 @@
+// no source code here
--- a/zokrates_cli/examples/error/forbidden_power_base.zok
+++ b/zokrates_cli/examples/error/forbidden_power_base.zok
@ -0,0 +1,2 @@
+def main(field a) -> (field):
+	return a*2**3
--- a/zokrates_cli/examples/error/out_of_for_scope.zok
+++ b/zokrates_cli/examples/error/out_of_for_scope.zok
@ -0,0 +1,4 @@
+def main() -> (field):
+	for field i in 0..5 do
+	endfor
+	return i
--- a/zokrates_cli/examples/error/shadowing.zok
+++ b/zokrates_cli/examples/error/shadowing.zok
@ -0,0 +1,7 @@
+def foo() -> (field):
+	return 1
+
+def main() -> (field):
+	field a = 2
+	field a = foo()
+	return 1
--- a/zokrates_cli/examples/error/unassigned.zok
+++ b/zokrates_cli/examples/error/unassigned.zok
@ -0,0 +1,4 @@
+def main() -> (field):
+	field a
+	field b = a + 1
+	return b
--- a/zokrates_cli/examples/error/wrongsyntax-error.zok
+++ b/zokrates_cli/examples/error/wrongsyntax-error.zok
@ -0,0 +1,16 @@
+//def wrong(a)
+//def (a):
+//def wrongtoo(a,):
+def main(a):
+  b = a + 5
+  //c = if x < 6 then b ele 5 fi + 2
+  //c = 5 + 2 * b + 5 b * 8 + a
+  //c = 5 + 2 * b + 5 \ a
+  //c = 5 + 2 *+ b + 5 \ a
+  //c *= 1
+  //c =
+  //c = 7 + a +
+  /// comment with one /
+  //return a + b \
+  return a + b
+  return a
--- a/zokrates_cli/examples/factorization.zok
+++ b/zokrates_cli/examples/factorization.zok
@ -0,0 +1,5 @@
+// a and b are factorization of c
+def main(field c, private field a, private field b) -> (field):
+  field d = a * b
+  c == d
+  return 1
--- a/zokrates_cli/examples/flatten.zok
+++ b/zokrates_cli/examples/flatten.zok
@ -0,0 +1,6 @@
+// this code needs flattening
+def main(field a) -> (field):
+  field b = a + 5 + a * a
+  field c = b + a + a * b * b
+  field d = a * b + c * c
+  return b + c + d
--- a/zokrates_cli/examples/for.zok
+++ b/zokrates_cli/examples/for.zok
@ -0,0 +1,7 @@
+def main(field a) -> (field):
+  field x = 7
+  for field i in 0..10 do
+    // x = x + a
+    x = x + a
+  endfor
+  return x
--- a/zokrates_cli/examples/functions/expressions.zok
+++ b/zokrates_cli/examples/functions/expressions.zok
@ -0,0 +1,10 @@
+def add(field a,field b) -> (field):
+  field v = a + b
+  return v
+
+// Expected for inputs 1,1: c=4, d=7, e=10
+def main(field a,field b) -> (field):
+   c = add(a*2+3*b-a,b-1)
+   d = add(a*b+2, a*b*c)
+   e = add(add(a,d),add(a,b))
+  return e
--- a/zokrates_cli/examples/functions/functions.zok
+++ b/zokrates_cli/examples/functions/functions.zok
@ -0,0 +1,6 @@
+def add(field f,field g) -> (field):
+  return f+g
+
+def main(field a, field b) -> (field):
+  c = add(a,b)
+  return c
--- a/zokrates_cli/examples/functions/lt_comparison
+++ b/zokrates_cli/examples/functions/lt_comparison
@ -0,0 +1,23 @@
+def lt(field a,field b) -> (field):
+    return if a < b then 1 else 0 fi
+
+def cutoff() -> (field):
+    return 31337
+
+def getThing(index) -> (field):
+    field result = 3
+    result = if index == 0 then 13 else result fi
+    result = if index == 1 then 23 else result fi
+    result = if index == 2 then 43 else result fi
+    result = if index == 3 then 53 else result fi
+    result = if index == 4 then 73 else result fi
+    result = if index == 5 then 83 else result fi
+    return result
+
+def cubeThing(field thing) -> (field):
+    return thing**3
+
+def main(field index) -> (field):
+    field thing = getThing(index)
+    thing = cubeThing(thing)
+    return lt(cutoff(), thing)
--- a/zokrates_cli/examples/functions/multi_functions.zok
+++ b/zokrates_cli/examples/functions/multi_functions.zok
@ -0,0 +1,13 @@
+def add(field a, field b) -> (field):
+  field v = a + b
+  return v + a
+
+def main(field a, field b,field c, field d) -> (field):
+  field g = a + b
+  x = add(a,b)
+  y = add(c,d)
+  g = add(x, g)
+  g = add(x, g)
+  field f = c + d + a
+  g = add(g+a, add(x,b))
+  return x + y + g + f
--- a/zokrates_cli/examples/functions/multi_shadowing.zok
+++ b/zokrates_cli/examples/functions/multi_shadowing.zok
@ -0,0 +1,11 @@
+def add(field a,field b) -> (field):
+  field v = a + b
+  return v
+
+def sub(field a, field b) -> (field):
+  return a-b
+
+def main(field a, field b) -> (field):
+  c = add(a,b)
+  d = sub(a,b)
+  return 0
--- a/zokrates_cli/examples/functions/no_args_multiple.zok
+++ b/zokrates_cli/examples/functions/no_args_multiple.zok
@ -0,0 +1,10 @@
+def const() -> (field):
+  return 123123
+
+def add(field a,field b) -> (field):
+  a=const()
+  return a+b
+
+def main(field a,field b) -> (field):
+  field c = add(a, b+const())
+  return const()
--- a/zokrates_cli/examples/functions/shadowing.zok
+++ b/zokrates_cli/examples/functions/shadowing.zok
@ -0,0 +1,6 @@
+def add(field a,field b) -> (field):
+  return a+b
+
+def main(field a,field b) -> (field):
+  field c = add(a,b)
+  return c
--- a/zokrates_cli/examples/functions_equivalent.zok
+++ b/zokrates_cli/examples/functions_equivalent.zok
@ -0,0 +1,3 @@
+def main(field a,field b) -> (field):
+  field c = a + b
+  return c
--- a/zokrates_cli/examples/if_eq.zok
+++ b/zokrates_cli/examples/if_eq.zok
@ -0,0 +1,7 @@
+// example using if-then-else-fi with ==
+// x = 1 -> 1 + 1 + 1 = 3
+// x = 2 -> 2 + 5 + 125 = 132
+def main(field x) -> (field):
+  field y = if x + 2 == 3 then 1 else 5 fi
+  field z = if y == x then x**3 else y**3 fi
+  return x + y + z
--- a/zokrates_cli/examples/imports/bar.zok
+++ b/zokrates_cli/examples/imports/bar.zok
@ -0,0 +1,2 @@
+def main() -> (field):
+	return 21
--- a/zokrates_cli/examples/imports/baz.zok
+++ b/zokrates_cli/examples/imports/baz.zok
@ -0,0 +1,2 @@
+def main() -> (field):
+	return 123
--- a/zokrates_cli/examples/imports/foo.zok
+++ b/zokrates_cli/examples/imports/foo.zok
@ -0,0 +1,4 @@
+import "./baz"
+
+def main() -> (field):
+	return baz()
--- a/zokrates_cli/examples/imports/import.zok
+++ b/zokrates_cli/examples/imports/import.zok
@ -0,0 +1,5 @@
+import "./foo"
+import "./bar"
+
+def main() -> (field):
+	return foo() + bar()
--- a/zokrates_cli/examples/imports/import_with_alias.zok
+++ b/zokrates_cli/examples/imports/import_with_alias.zok
@ -0,0 +1,4 @@
+import "./foo" as d
+
+def main() -> (field):
+	return d()
--- a/zokrates_cli/examples/left_side_call.zok
+++ b/zokrates_cli/examples/left_side_call.zok
@ -0,0 +1,6 @@
+def foo() -> (field):
+	return 1
+
+def main() -> (field):
+	foo() + (1 + 44*3) == 1
+	return 1
--- a/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok
+++ b/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok
@ -0,0 +1,27 @@
+import "hashes/pedersen/512bit" as hash
+import "ecc/edwardsCompress" as edwardsCompress
+import "ecc/babyjubjubParams" as context
+import "hashes/utils/256bitsDirectionHelper" as multiplex
+import "utils/binary/not" as NOT
+// Merke-Tree inclusion proof for tree depth 3 using SNARK efficient pedersen hashes 
+// directionSelector=> 1/true if current digest is on the rhs of the hash
+def main(field[256] rootDigest, private field[256] leafDigest, private field[3] directionSelector, field[256] PathDigest0, private field[256] PathDigest1, private field[256] PathDigest2) -> (field):
+	context = context()
+
+	//Setup
+	field[256] currentDigest = leafDigest
+	
+	//Loop up the tree
+	preimage = multiplex(directionSelector[0], currentDigest, PathDigest0)
+	currentDigest = hash(preimage)
+
+	preimage = multiplex(directionSelector[1], currentDigest, PathDigest1)
+	currentDigest = hash(preimage)
+
+	preimage = multiplex(directionSelector[2], currentDigest, PathDigest2)
+	currentDigest = hash(preimage)
+
+	rootDigest == currentDigest
+	
+	return 1 //return true in success 
+
--- a/zokrates_cli/examples/merkleTree/sha256PathProof3.zok
+++ b/zokrates_cli/examples/merkleTree/sha256PathProof3.zok
@ -0,0 +1,31 @@
+import "hashes/sha256/512bit" as sha256
+import "utils/multiplexer/256bit" as multiplex
+import "utils/binary/not" as NOT
+
+// Merke-Tree inclusion proof for tree depth 3 
+
+def main(field treeDepth, field[256] rootDigest, private field[256] leafDigest, private field[2] directionSelector, field[256] PathDigest0, private field[256] PathDigest1) -> (field):
+
+	//Setup
+	field[256] currentDigest = leafDigest
+	field counter = 1
+	field currentDirection = 0
+	
+	//Loop up the tree
+	currentDirection = directionSelector[0]
+	lhs = multiplex(currentDirection, currentDigest, PathDigest0)
+	rhs = multiplex(NOT(currentDirection), currentDigest, PathDigest0)
+	currentDigest = sha256(lhs, rhs)
+	counter = counter + 1
+
+	currentDirection = directionSelector[1]
+	lhs = multiplex(currentDirection, currentDigest, PathDigest1)
+	rhs = multiplex(NOT(currentDirection), currentDigest, PathDigest1)
+	currentDigest = sha256(lhs, rhs)
+	counter = counter + 1
+
+	//Asserts
+	counter == treeDepth
+	rootDigest == currentDigest
+
+	return 1 //return true in success 
--- a/zokrates_cli/examples/merkleTree/testpedersenPathProof3.zok
+++ b/zokrates_cli/examples/merkleTree/testpedersenPathProof3.zok
@ -0,0 +1,20 @@
+import "./pedersenPathProof3"
+// Merke-Tree inclusion proof for tree depth 3 
+// def main(field treeDepth, field[256] rootDigest, private field[256] leafDigest, private field[2] directionSelector, field[256] PathDigest0, private field[256] PathDigest1) -> (field):
+def main() -> (field):
+
+	//Setup
+	field[256] leafDigest = [0,1,1,0,1,1,1,1,1,0,0,1,1,0,1,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,0,1,1,1,1,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,0,1,0,0,0,1,1,0,1,1,0,0,1,0,0,0,1,1,1,1,0,0,0,0,1,0,1,1,0,1,1,0,0,1,1,0,1,1,0,1,0,1,1,1,0,0,0,1,1,0,1,1,1,0,0,1,0,1,1,1,1,0,0,0,1,0,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0,1,0,1,0,0,0,0,1,0,1,1,0,1,1,1,0,0,1,1,0,0,0,1,0,1,0,1,0,1]
+	
+	//Loop up the tree
+	field[256] PathDigest0 = [0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,1,0,1,0,1,0,0,1,1,1,0,1,1,1,0,0,1,1,0,1,1,1,0,1,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,1,1,0,1,0,0,1,1,1,1,1,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1,0,1,0,0,1,0,1,1,0,0,1,1,1,0,1,1,0,0,1,1,0,0,0,1,1,0,1,1,0,0,0,1,1,1,0,0,1,1,0,1,1,1,1,0,1,0,1,1,1,0,0,1,1,0,1,0,0,0,1,0,0,0,1,1,1,0,0,1,1,1,1,0,1,0,0,0,1,0,0,0,1,1,1,1,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,0,0,1,0,0,0,0,1,0,1,1,1,1,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,0,0,0,0,1,1,1,1]
+	field[256] PathDigest1 = [0,1,1,1,1,1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,0,1,1,0,0,1,1,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,1,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,1,1,1,1,0,1,0,0,1,0,0,0,0,1,1,0,0,0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,1,0,1,1,1,1,1,0,1,0,0,1,0,1,0,1,1,0,1,0,1,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1,0,1,1,0,0,1,1,0,1,0,1,1,0,1,1,1,1,0,0,0,0,1,0,1,0,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,1,1,0,1,0,1,0,0,1,1,1,1,1,0,1,0,1,1,0,0,0,1,1,0,0,0,1,1,1,0,0,1,1,1,1,1,0,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,1,0,1,0,0,1,1,0,0,0,1,0,1,0,0]
+	field[256] PathDigest2 = [1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,1,1,1,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,1,0,1,1,0,0,0,1,1,1,0,0,0,0,1,1,0,0,1,1,1,0,0,0,1,0,0,1,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1,0,1,0,0,1,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,0,0,1,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,1,0,1,0,0,0,1,1,0,1,1,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1,1,0,0,0,1,1,0,1,1,1,1,1,1,1,0,1,0,1,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,1,0,1,1,1,0,1,0,1,1,0,0,0,0,1,0,1,0,1,1,1,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,1]
+
+	// 	//Asserts
+	field[256] rootDigest = [0,0,1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,1,0,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,1,0,0,1,1,1,0,1,1,0,1,1,1,1,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,1,0,0,0,1,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,0,0,0,0,1,0,1,1,0,1,1,0,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,0,0,0,1,0,1,1,1,0,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,1,0,0,1,1,1,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,1,1,0,0,0,1,0,0,1,0,1,1,1,0,0]
+
+	field success = pedersenPathProof3(rootDigest, leafDigest, [0, 0, 0], PathDigest0, PathDigest1, PathDigest2)
+
+	return 1 //return true in success 
+
--- a/zokrates_cli/examples/merkleTree/testsha256PathProof3.zok
+++ b/zokrates_cli/examples/merkleTree/testsha256PathProof3.zok
@ -0,0 +1,13 @@
+import "./sha256PathProof3" as merkleTreeProof
+def main() -> (field):
+
+    field treeDepth = 3
+	field[256] rootDigest = [1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,0 ,0 ,1 ,1 ,1 ,1 ,0 ,0 ,1 ,0 ,1 ,0 ,1 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,0 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,1 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,1 ,1 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,1 ,1 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,1 ,0 ,0 ,1 ,0 ,1 ,1 ,1 ,0 ,1 ,0 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,0 ,0 ,0 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,1 ,0 ,0 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,1 ,1 ,1 ,1 ,0 ,0 ,1 ,0 ,0 ,1 ,1 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,0]
+    field[256]  leafDigest = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]
+    field[2] directionSelector = [0, 0] 
+    field[256] PathDigest0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1] 
+    field[256] PathDigest1	= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]
+
+    field out = merkleTreeProof(treeDepth,rootDigest,leafDigest,directionSelector,PathDigest0,PathDigest1)
+
+    return 1
--- a/zokrates_cli/examples/multi_return.zok
+++ b/zokrates_cli/examples/multi_return.zok
@ -0,0 +1,7 @@
+def foo(field a) -> (field, field, field, field):
+	field b = 12*a
+	return a, 2*a, 5*b, a*b
+
+def main(field i) -> (field):
+	field x, field y, field z, field t = foo(i)
+    return 1
--- a/zokrates_cli/examples/multi_return_sum.zok
+++ b/zokrates_cli/examples/multi_return_sum.zok
@ -0,0 +1,5 @@
+def foo() -> (field, field):
+   return 1, 2
+def main() -> (field, field):
+   field a, field b = foo()
+   return a + b, b - a
--- a/zokrates_cli/examples/multiple_witnesses.zok
+++ b/zokrates_cli/examples/multiple_witnesses.zok
@ -0,0 +1,4 @@
+// this code does not need to be flattened
+def main(field x, field a, field b) -> (field):
+  a == b * 7
+  return x + a + b
--- a/zokrates_cli/examples/n_choose_k.zok
+++ b/zokrates_cli/examples/n_choose_k.zok
@ -0,0 +1,12 @@
+// Binomial Coeffizient, n!/(k!*(n-k)!).
+def fac(field x) -> (field):
+    field f = 1
+    field counter = 0
+    for field i in 1..100 do
+        f = if counter == x then f else f * i fi
+        counter = if counter == x then counter else counter + 1 fi
+    endfor
+    return f
+
+def main(field n, field k) -> (field):
+    return fac(n)/(fac(k)*fac(n-k))
--- a/zokrates_cli/examples/no_flatten.zok
+++ b/zokrates_cli/examples/no_flatten.zok
@ -0,0 +1,6 @@
+// this code does not need to be flattened
+def main(field x, field y, field z) -> (field):
+  field a = x + 3*y - z *2 - x * 12
+  3*y - z *2 - x * 12 == a - x
+  (x + y) - ((z + 3*x) - y) == (x - y) + ((2*x - 4*y) + (4*y - 2*z))
+  return x
--- a/zokrates_cli/examples/pow.zok
+++ b/zokrates_cli/examples/pow.zok
@ -0,0 +1,16 @@
+def main() -> (field):
+  field x = 2**4
+  x == 16
+  x = x**2
+  x == 256
+  field y = 3**3
+  y == 27
+  field z = y**2
+  z == 729
+  field a = 5**2
+  a == 25
+  a = a**2
+  a == 625
+  a = 5**5
+  a == 3125
+  return 1
--- a/zokrates_cli/examples/propagate.zok
+++ b/zokrates_cli/examples/propagate.zok
@ -0,0 +1,9 @@
+def main() -> (field):
+	field a = 1 + 2 + 3
+	field b = if 1 < a then 3 else a + 3 fi
+	field c = if b + a == 2 then 1 else b fi
+	for field e in 0..2 do
+		field g = 4
+		c = c + g
+	endfor
+	return c * a
--- a/zokrates_cli/examples/propagate_call.zok
+++ b/zokrates_cli/examples/propagate_call.zok
@ -0,0 +1,7 @@
+def foo(field a, field b) -> (field, field):
+	a == b + 2
+	return a, b
+
+def main() -> (field):
+	a, b = foo(1, 1)
+	return a + b
--- a/zokrates_cli/examples/reassignment.zok
+++ b/zokrates_cli/examples/reassignment.zok
@ -0,0 +1,7 @@
+def main(field x) -> (field):
+  field a = x + 5
+  field b = a + x
+  a = 7
+  field c = a + b
+  a = a + 5
+  return a + c
--- a/zokrates_cli/examples/reduceable_exponent.zok
+++ b/zokrates_cli/examples/reduceable_exponent.zok
@ -0,0 +1,3 @@
+def main() -> (field):
+	field a = 2
+	return 2**(a**2 + 2)
--- a/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok
+++ b/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok
@ -0,0 +1,10 @@
+// we can compare numbers up to 2^(pbits - 2) - 1, ie any number which fits in (pbits - 2) bits
+// lt should not work for the maxvalue = 2^(pbits - 2) - 1 augmented by one
+// /!\ should be called with a = 0
+
+def main(field a) -> (field):
+  field pbits = 254
+  // maxvalue = 2**252 - 1
+  field maxvalue = a + 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1
+  // we added a = 0 to prevent the condition to be evaluated at compile time
+  return if 0 < (maxvalue + 1) then 1 else 0 fi
--- a/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok
+++ b/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok
@ -0,0 +1,7 @@
+// as p - 1 is greater than p/2, comparing to it should fail
+// /!\ should be called with a = 0
+
+def main(field a) -> (field):
+  field p = 21888242871839275222246405745257275088548364400416034343698204186575808495617 + a
+  // we added a = 0 to prevent the condition to be evaluated at compile time
+  return if 0 < p - 1 then 1 else 0 fi
--- a/zokrates_cli/examples/sha256/binary/andxorandxorand.zok
+++ b/zokrates_cli/examples/sha256/binary/andxorandxorand.zok
@ -0,0 +1,7 @@
+// ANDXORANDXORAND
+
+import "utils/binary/xor" as XOR
+import "utils/binary/and" as AND
+
+def main(field a, field b, field c) -> (field):
+	return XOR(XOR(AND(a, b), AND(a, c)), AND(b, c))
--- a/zokrates_cli/examples/sha256/binary/andxornotand.zok
+++ b/zokrates_cli/examples/sha256/binary/andxornotand.zok
@ -0,0 +1,8 @@
+// ANDXORNOTAND
+
+import "utils/binary/and" as AND
+import "utils/binary/xor" as XOR
+import "utils/binary/not" as NOT
+
+def main(field a, field b, field c) -> (field):
+	return XOR(AND(a, b), AND(NOT(a), c))
--- a/Show more
+++ b/Show more