diff --git a/.gitignore b/.gitignore index af3a8e8beb2..8aec0edeadc 100644 --- a/.gitignore +++ b/.gitignore @@ -22,5 +22,3 @@ result **/target !crates/nargo_cli/tests/test_data/*/target !crates/nargo_cli/tests/test_data/*/target/witness.tr -!crates/nargo_cli/tests/test_data_ssa_refactor/*/target -!crates/nargo_cli/tests/test_data_ssa_refactor/*/target/witness.tr \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index 4e1510c8df9..c4235b2c913 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -663,9 +663,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.3.16" +version = "4.3.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74bb1b4028935821b2d6b439bba2e970bdcf740832732437ead910c632e30d7d" +checksum = "5fd304a20bff958a57f04c4e96a2e7594cc4490a0e809cbd48bb6437edaa452d" dependencies = [ "clap_builder", "clap_derive", @@ -674,9 +674,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.3.16" +version = "4.3.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ae467cbb0111869b765e13882a1dbbd6cb52f58203d8b80c44f667d4dd19843" +checksum = "01c6a3f08f1fe5662a35cfe393aec09c4df95f60ee93b7556505260f75eee9e1" dependencies = [ "anstream", "anstyle", @@ -1237,6 +1237,7 @@ version = "0.9.0" dependencies = [ "cfg-if", "codespan-reporting", + "iter-extended", "rust-embed", "serde", "tempfile", @@ -1982,11 +1983,12 @@ dependencies = [ "noirc_abi", "noirc_driver", "noirc_errors", + "noirc_frontend", + "regex", "rustc_version", "serde", "serde_json", "thiserror", - "toml", ] [[package]] @@ -2128,6 +2130,7 @@ dependencies = [ "iter-extended", "noirc_abi", "noirc_errors", + "regex", "rustc-hash", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index ca6fbf62299..0b05d783e11 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,7 +38,7 @@ noirc_evaluator = { path = "crates/noirc_evaluator" } noirc_frontend = { path = "crates/noirc_frontend" } noir_wasm = { path = "crates/wasm" } cfg-if = "1.0.0" -clap = { version = "4.1.4", features = ["derive"] } +clap = { version = "4.3.19", features = ["derive"] } codespan = { version = "0.11.1", features = ["serialization"] } codespan-lsp = "0.11.1" codespan-reporting = "0.11.1" diff --git a/crates/fm/Cargo.toml b/crates/fm/Cargo.toml index 48f1932f9d6..2fc7eac6d8f 100644 --- a/crates/fm/Cargo.toml +++ b/crates/fm/Cargo.toml @@ -17,3 +17,4 @@ wasm-bindgen.workspace = true [dev-dependencies] tempfile = "3.2.0" +iter-extended.workspace = true diff --git a/crates/fm/src/lib.rs b/crates/fm/src/lib.rs index 368043ea601..4c2ce39dd40 100644 --- a/crates/fm/src/lib.rs +++ b/crates/fm/src/lib.rs @@ -30,7 +30,7 @@ pub struct FileManager { impl FileManager { pub fn new(root: &Path) -> Self { Self { - root: normalize_path(root), + root: root.normalize(), file_map: Default::default(), id_to_path: Default::default(), path_to_id: Default::default(), @@ -44,7 +44,7 @@ impl FileManager { // TODO: The stdlib path should probably be an absolute path rooted in something people would never create file_name.to_path_buf() } else { - normalize_path(&self.root.join(file_name)) + self.root.join(file_name).normalize() }; // Check that the resolved path already exists in the file map, if it is, we return it. @@ -80,7 +80,7 @@ impl FileManager { self.id_to_path.get(&file_id).unwrap().0.as_path() } - pub fn resolve_path(&mut self, anchor: FileId, mod_name: &str) -> Result { + pub fn find_module(&mut self, anchor: FileId, mod_name: &str) -> Result { let mut candidate_files = Vec::new(); let anchor_path = self.path(anchor).to_path_buf(); @@ -101,13 +101,33 @@ impl FileManager { } } -/// Replacement for `std::fs::canonicalize` that doesn't verify the path exists. -/// -/// Plucked from https://github.com/rust-lang/cargo/blob/fede83ccf973457de319ba6fa0e36ead454d2e20/src/cargo/util/paths.rs#L61 -/// Advice from https://www.reddit.com/r/rust/comments/hkkquy/comment/fwtw53s/ -fn normalize_path(path: &Path) -> PathBuf { - let mut components = path.components().peekable(); - let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { +pub trait NormalizePath { + /// Replacement for `std::fs::canonicalize` that doesn't verify the path exists. + /// + /// Plucked from https://github.com/rust-lang/cargo/blob/fede83ccf973457de319ba6fa0e36ead454d2e20/src/cargo/util/paths.rs#L61 + /// Advice from https://www.reddit.com/r/rust/comments/hkkquy/comment/fwtw53s/ + fn normalize(&self) -> PathBuf; +} + +impl NormalizePath for PathBuf { + fn normalize(&self) -> PathBuf { + let components = self.components(); + resolve_components(components) + } +} + +impl NormalizePath for &Path { + fn normalize(&self) -> PathBuf { + let components = self.components(); + resolve_components(components) + } +} + +fn resolve_components<'a>(components: impl Iterator>) -> PathBuf { + let mut components = components.peekable(); + + // Preserve path prefix if one exists. + let mut normalized_path = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { components.next(); PathBuf::from(c.as_os_str()) } else { @@ -116,20 +136,46 @@ fn normalize_path(path: &Path) -> PathBuf { for component in components { match component { - Component::Prefix(..) => unreachable!(), + Component::Prefix(..) => unreachable!("Path cannot contain multiple prefixes"), Component::RootDir => { - ret.push(component.as_os_str()); + normalized_path.push(component.as_os_str()); } Component::CurDir => {} Component::ParentDir => { - ret.pop(); + normalized_path.pop(); } Component::Normal(c) => { - ret.push(c); + normalized_path.push(c); } } } - ret + + normalized_path +} + +#[cfg(test)] +mod path_normalization { + use iter_extended::vecmap; + use std::path::PathBuf; + + use crate::NormalizePath; + + #[test] + fn normalizes_paths_correctly() { + // Note that tests are run on unix so prefix handling can't be tested (as these only exist on Windows) + let test_cases = vecmap( + [ + ("/", "/"), // Handles root + ("/foo/bar/../baz/../bar", "/foo/bar"), // Handles backtracking + ("/././././././././baz", "/baz"), // Removes no-ops + ], + |(unnormalized, normalized)| (PathBuf::from(unnormalized), PathBuf::from(normalized)), + ); + + for (path, expected_result) in test_cases { + assert_eq!(path.normalize(), expected_result); + } + } } /// Takes a path to a noir file. This will panic on paths to directories @@ -149,7 +195,7 @@ mod tests { fn create_dummy_file(dir: &TempDir, file_name: &Path) { let file_path = dir.path().join(file_name); - let _file = std::fs::File::create(file_path.clone()).unwrap(); + let _file = std::fs::File::create(file_path).unwrap(); } #[test] @@ -165,7 +211,7 @@ mod tests { let dep_file_name = Path::new("foo.nr"); create_dummy_file(&dir, dep_file_name); - fm.resolve_path(file_id, "foo").unwrap(); + fm.find_module(file_id, "foo").unwrap(); } #[test] fn path_resolve_file_module_other_ext() { @@ -175,7 +221,7 @@ mod tests { let mut fm = FileManager::new(dir.path()); - let file_id = fm.add_file(&file_name).unwrap(); + let file_id = fm.add_file(file_name).unwrap(); assert!(fm.path(file_id).ends_with("foo")); } @@ -189,7 +235,7 @@ mod tests { let file_name = Path::new("lib.nr"); create_dummy_file(&dir, file_name); - let file_id = fm.add_file(&file_name).unwrap(); + let file_id = fm.add_file(file_name).unwrap(); // Create a sub directory // we now have: @@ -212,10 +258,10 @@ mod tests { create_dummy_file(&dir, Path::new(&format!("{}.nr", sub_dir_name))); // First check for the sub_dir.nr file and add it to the FileManager - let sub_dir_file_id = fm.resolve_path(file_id, sub_dir_name).unwrap(); + let sub_dir_file_id = fm.find_module(file_id, sub_dir_name).unwrap(); // Now check for files in it's subdirectory - fm.resolve_path(sub_dir_file_id, "foo").unwrap(); + fm.find_module(sub_dir_file_id, "foo").unwrap(); } /// Tests that two identical files that have different paths are treated as the same file @@ -238,7 +284,7 @@ mod tests { let second_file_name = PathBuf::from(sub_sub_dir.path()).join("./../../lib.nr"); // Add both files to the file manager - let file_id = fm.add_file(&file_name).unwrap(); + let file_id = fm.add_file(file_name).unwrap(); let second_file_id = fm.add_file(&second_file_name).unwrap(); assert_eq!(file_id, second_file_id); diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index bd4112218e4..1c02c802808 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -22,7 +22,7 @@ use lsp_types::{ InitializeParams, InitializeResult, InitializedParams, Position, PublishDiagnosticsParams, Range, ServerCapabilities, TextDocumentSyncOptions, }; -use noirc_driver::{check_crate, create_local_crate}; +use noirc_driver::{check_crate, prepare_crate}; use noirc_errors::{DiagnosticKind, FileDiagnostic}; use noirc_frontend::{ graph::{CrateGraph, CrateType}, @@ -190,7 +190,7 @@ fn on_code_lens_request( } }; - let crate_id = create_local_crate(&mut context, file_path, CrateType::Binary); + let crate_id = prepare_crate(&mut context, file_path, CrateType::Binary); // We ignore the warnings and errors produced by compilation for producing codelenses // because we can still get the test functions even if compilation fails @@ -283,7 +283,7 @@ fn on_did_save_text_document( } }; - let crate_id = create_local_crate(&mut context, file_path, CrateType::Binary); + let crate_id = prepare_crate(&mut context, file_path, CrateType::Binary); let mut diagnostics = Vec::new(); diff --git a/crates/lsp/src/lib_hacky.rs b/crates/lsp/src/lib_hacky.rs index 72a2625fcac..13bb2b82847 100644 --- a/crates/lsp/src/lib_hacky.rs +++ b/crates/lsp/src/lib_hacky.rs @@ -19,7 +19,7 @@ use lsp_types::{ InitializedParams, Position, PublishDiagnosticsParams, Range, ServerCapabilities, TextDocumentSyncOptions, }; -use noirc_driver::{check_crate, create_local_crate, create_non_local_crate, propagate_dep}; +use noirc_driver::{check_crate, prepare_crate, propagate_dep}; use noirc_errors::{DiagnosticKind, FileDiagnostic}; use noirc_frontend::{ graph::{CrateGraph, CrateId, CrateType}, @@ -286,7 +286,7 @@ fn create_context_at_path( } let nargo_toml_path = find_nearest_parent_file(&file_path, &["Nargo.toml"]); - let current_crate_id = create_local_crate(&mut context, &file_path, CrateType::Binary); + let current_crate_id = prepare_crate(&mut context, &file_path, CrateType::Binary); // TODO(AD): undo hacky dependency resolution if let Some(nargo_toml_path) = nargo_toml_path { @@ -297,8 +297,7 @@ fn create_context_at_path( .parent() .unwrap() // TODO .join(PathBuf::from(&dependency_path).join("src").join("lib.nr")); - let library_crate = - create_non_local_crate(&mut context, &path_to_lib, CrateType::Library); + let library_crate = prepare_crate(&mut context, &path_to_lib, CrateType::Library); propagate_dep(&mut context, library_crate, &crate_name.parse().unwrap()); } } diff --git a/crates/nargo/Cargo.toml b/crates/nargo/Cargo.toml index 6c053cba931..3039268281c 100644 --- a/crates/nargo/Cargo.toml +++ b/crates/nargo/Cargo.toml @@ -14,10 +14,11 @@ rustc_version = "0.4.0" acvm.workspace = true noirc_abi.workspace = true noirc_driver.workspace = true +noirc_frontend.workspace = true iter-extended.workspace = true -toml.workspace = true serde.workspace = true serde_json.workspace = true thiserror.workspace = true noirc_errors.workspace = true -base64.workspace = true \ No newline at end of file +base64.workspace = true +regex = "1.9.1" diff --git a/crates/nargo_cli/src/constants.rs b/crates/nargo/src/constants.rs similarity index 55% rename from crates/nargo_cli/src/constants.rs rename to crates/nargo/src/constants.rs index d3e6b7f28e1..5e448277694 100644 --- a/crates/nargo_cli/src/constants.rs +++ b/crates/nargo/src/constants.rs @@ -1,23 +1,23 @@ // Directories /// The directory for the `nargo contract` command output -pub(crate) const CONTRACT_DIR: &str = "contract"; +pub const CONTRACT_DIR: &str = "contract"; /// The directory to store serialized circuit proofs. -pub(crate) const PROOFS_DIR: &str = "proofs"; +pub const PROOFS_DIR: &str = "proofs"; /// The directory to store Noir source files -pub(crate) const SRC_DIR: &str = "src"; +pub const SRC_DIR: &str = "src"; /// The directory to store circuits' serialized ACIR representations. -pub(crate) const TARGET_DIR: &str = "target"; +pub const TARGET_DIR: &str = "target"; // Files /// The file from which Nargo pulls prover inputs -pub(crate) const PROVER_INPUT_FILE: &str = "Prover"; +pub const PROVER_INPUT_FILE: &str = "Prover"; /// The file from which Nargo pulls verifier inputs -pub(crate) const VERIFIER_INPUT_FILE: &str = "Verifier"; +pub const VERIFIER_INPUT_FILE: &str = "Verifier"; /// The package definition file for a Noir project. -pub(crate) const PKG_FILE: &str = "Nargo.toml"; +pub const PKG_FILE: &str = "Nargo.toml"; // Extensions /// The extension for files containing circuit proofs. -pub(crate) const PROOF_EXT: &str = "proof"; +pub const PROOF_EXT: &str = "proof"; /// The extension for files containing proof witnesses. -pub(crate) const WITNESS_EXT: &str = "tr"; +pub const WITNESS_EXT: &str = "tr"; diff --git a/crates/nargo/src/lib.rs b/crates/nargo/src/lib.rs index 24605de7849..fda02cf98c2 100644 --- a/crates/nargo/src/lib.rs +++ b/crates/nargo/src/lib.rs @@ -8,8 +8,10 @@ //! Noir Package Manager abbreviated is npm, which is already taken. pub mod artifacts; +pub mod constants; mod errors; -pub mod manifest; pub mod ops; +pub mod package; +pub mod workspace; pub use self::errors::NargoError; diff --git a/crates/nargo/src/manifest/errors.rs b/crates/nargo/src/manifest/errors.rs deleted file mode 100644 index 250211de6fb..00000000000 --- a/crates/nargo/src/manifest/errors.rs +++ /dev/null @@ -1,26 +0,0 @@ -use std::path::PathBuf; -use thiserror::Error; - -/// Errors covering situations where a package is either missing or malformed. -#[derive(Debug, Error)] -pub enum InvalidPackageError { - /// Package doesn't have a manifest file - #[error("cannot find a Nargo.toml in {}", .0.display())] - MissingManifestFile(PathBuf), - - /// Package manifest is unreadable. - #[error("Nargo.toml is badly formed, could not parse.\n\n {0}")] - MalformedManifestFile(#[from] toml::de::Error), - - /// Package does not contain Noir source files. - #[error("cannot find src directory in path {}", .0.display())] - NoSourceDir(PathBuf), - - /// Package has neither of `main.nr` and `lib.nr`. - #[error("package must contain either a `lib.nr`(Library) or a `main.nr`(Binary).")] - ContainsZeroCrates, - - /// Package has both a `main.nr` (for binaries) and `lib.nr` (for libraries) - #[error("package cannot contain both a `lib.nr` and a `main.nr`")] - ContainsMultipleCrates, -} diff --git a/crates/nargo/src/manifest/mod.rs b/crates/nargo/src/manifest/mod.rs deleted file mode 100644 index f5a247cf72a..00000000000 --- a/crates/nargo/src/manifest/mod.rs +++ /dev/null @@ -1,147 +0,0 @@ -use serde::Deserialize; -use std::{collections::BTreeMap, path::PathBuf}; - -mod errors; -pub use self::errors::InvalidPackageError; - -#[derive(Debug, Deserialize, Clone)] -pub struct PackageManifest { - pub package: PackageMetadata, - pub dependencies: BTreeMap, -} - -/// Contains all the information about a package, as loaded from a `Nargo.toml`. -/// Represents a manifest, which can be either a package manifest or a workspace manifest. -#[derive(Debug, Deserialize, Clone)] -#[serde(untagged)] -pub enum Manifest { - /// Represents a package manifest. - Package(PackageManifest), - /// Represents a workspace manifest. - Workspace(Workspace), -} - -impl Manifest { - pub fn from_toml_str(toml_as_string: &str) -> Result { - let manifest = toml::from_str(toml_as_string)?; - Ok(manifest) - } - - pub fn to_package(self) -> Option { - match self { - Self::Package(v) => Some(v), - _ => None, - } - } -} - -impl PackageManifest { - /// Returns whether the package has a local dependency. - // Local paths are usually relative and are discouraged when sharing libraries - // It is better to separate these into different packages. - pub fn has_local_dependency(&self) -> bool { - self.dependencies.values().any(|dep| matches!(dep, Dependency::Path { .. })) - } -} - -/// Configuration of a workspace in a manifest. -/// Indicates that `[workspace]` was present and the members were specified as well. -#[derive(Debug, Deserialize, Clone)] -pub struct Workspace { - #[serde(rename = "workspace")] - pub config: WorkspaceConfig, -} - -#[derive(Default, Debug, Deserialize, Clone)] -#[serde(rename_all = "kebab-case")] -pub struct WorkspaceConfig { - /// List of members in this workspace. - pub members: Vec, - /// Specifies the default crate to interact with in the context (similarly to how we have nargo as the default crate in this repository). - pub default_member: Option, -} - -#[allow(dead_code)] -#[derive(Default, Debug, Deserialize, Clone)] -pub struct PackageMetadata { - #[serde(default = "panic_missing_name")] - pub name: String, - description: Option, - authors: Vec, - // If not compiler version is supplied, the latest is used - // For now, we state that all packages must be compiled under the same - // compiler version. - // We also state that ACIR and the compiler will upgrade in lockstep. - // so you will not need to supply an ACIR and compiler version - compiler_version: Option, - backend: Option, - license: Option, -} - -// TODO: Remove this after a couple of breaking releases (added in 0.10.0) -fn panic_missing_name() -> String { - panic!( - r#" - -Failed to parse `Nargo.toml`. - -`Nargo.toml` now requires a "name" field for Noir packages. - -```toml -[package] -name = "package_name" -``` - -Modify your `Nargo.toml` similarly to above and rerun the command. - -"# - ) -} - -#[derive(Debug, Deserialize, Clone)] -#[serde(untagged)] -/// Enum representing the different types of ways to -/// supply a source for the dependency -pub enum Dependency { - Github { git: String, tag: String }, - Path { path: String }, -} - -#[test] -fn parse_standard_toml() { - let src = r#" - - [package] - name = "test" - authors = ["kev", "foo"] - compiler_version = "0.1" - - [dependencies] - rand = { tag = "next", git = "https://github.com/rust-lang-nursery/rand"} - cool = { tag = "next", git = "https://github.com/rust-lang-nursery/rand"} - hello = {path = "./noir_driver"} - "#; - - assert!(Manifest::from_toml_str(src).is_ok()); -} - -#[test] -fn parse_workspace_toml() { - let src = r#" - [workspace] - members = ["a", "b"] - "#; - - assert!(Manifest::from_toml_str(src).is_ok()); -} - -#[test] -fn parse_workspace_default_member_toml() { - let src = r#" - [workspace] - members = ["a", "b"] - default-member = "a" - "#; - - assert!(Manifest::from_toml_str(src).is_ok()); -} diff --git a/crates/nargo/src/ops/execute.rs b/crates/nargo/src/ops/execute.rs index 13ea64ed261..2a126443468 100644 --- a/crates/nargo/src/ops/execute.rs +++ b/crates/nargo/src/ops/execute.rs @@ -10,6 +10,7 @@ pub fn execute_circuit( _backend: &B, circuit: Circuit, initial_witness: WitnessMap, + show_output: bool, ) -> Result { let mut acvm = ACVM::new(B::default(), circuit.opcodes, initial_witness); @@ -23,7 +24,7 @@ pub fn execute_circuit( } ACVMStatus::Failure(error) => return Err(error.into()), ACVMStatus::RequiresForeignCall(foreign_call) => { - let foreign_call_result = ForeignCall::execute(&foreign_call)?; + let foreign_call_result = ForeignCall::execute(&foreign_call, show_output)?; acvm.resolve_pending_foreign_call(foreign_call_result); } } diff --git a/crates/nargo/src/ops/foreign_calls.rs b/crates/nargo/src/ops/foreign_calls.rs index ea7f9be21b4..4d2f5988e38 100644 --- a/crates/nargo/src/ops/foreign_calls.rs +++ b/crates/nargo/src/ops/foreign_calls.rs @@ -3,7 +3,8 @@ use acvm::{ pwg::ForeignCallWaitInfo, }; use iter_extended::vecmap; -use noirc_abi::{decode_string_value, decode_value, input_parser::json::JsonTypes, AbiType}; +use noirc_abi::{decode_string_value, input_parser::InputValueDisplay, AbiType}; +use regex::{Captures, Regex}; use crate::errors::ForeignCallError; @@ -41,11 +42,14 @@ impl ForeignCall { pub(crate) fn execute( foreign_call: &ForeignCallWaitInfo, + show_output: bool, ) -> Result { let foreign_call_name = foreign_call.function.as_str(); match Self::lookup(foreign_call_name) { Some(ForeignCall::Println) => { - Self::execute_println(&foreign_call.inputs)?; + if show_output { + Self::execute_println(&foreign_call.inputs)?; + } Ok(ForeignCallResult { values: vec![] }) } Some(ForeignCall::Sequence) => { @@ -63,31 +67,89 @@ impl ForeignCall { } fn execute_println(foreign_call_inputs: &[Vec]) -> Result<(), ForeignCallError> { - let (abi_type, input_values) = fetch_abi_type(foreign_call_inputs)?; + let (is_fmt_str, foreign_call_inputs) = + foreign_call_inputs.split_last().ok_or(ForeignCallError::MissingForeignCallInputs)?; - // We must use a flat map here as each value in a struct will be in a separate input value - let mut input_values_as_fields = - input_values.iter().flat_map(|values| values.iter().map(|value| value.to_field())); - let decoded_value = decode_value(&mut input_values_as_fields, &abi_type)?; - - let json_value = JsonTypes::try_from_input_value(&decoded_value, &abi_type)?; - - println!("{json_value}"); + let output_string = if is_fmt_str[0].to_field().is_one() { + convert_fmt_string_inputs(foreign_call_inputs)? + } else { + convert_string_inputs(foreign_call_inputs)? + }; + println!("{output_string}"); Ok(()) } } -/// Fetch the abi type from the foreign call input -/// The remaining input values should hold the values to be printed -fn fetch_abi_type( - foreign_call_inputs: &[Vec], -) -> Result<(AbiType, &[Vec]), ForeignCallError> { +fn convert_string_inputs(foreign_call_inputs: &[Vec]) -> Result { + // Fetch the abi type from the foreign call input + // The remaining input values should hold what is to be printed let (abi_type_as_values, input_values) = foreign_call_inputs.split_last().ok_or(ForeignCallError::MissingForeignCallInputs)?; + let abi_type = fetch_abi_type(abi_type_as_values)?; + + // We must use a flat map here as each value in a struct will be in a separate input value + let mut input_values_as_fields = + input_values.iter().flat_map(|values| vecmap(values, |value| value.to_field())); + + let input_value_display = + InputValueDisplay::try_from_fields(&mut input_values_as_fields, abi_type)?; + + Ok(input_value_display.to_string()) +} + +fn convert_fmt_string_inputs( + foreign_call_inputs: &[Vec], +) -> Result { + let (message_as_values, input_and_abi_values) = + foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?; + + let message_as_fields = vecmap(message_as_values, |value| value.to_field()); + let message_as_string = decode_string_value(&message_as_fields); + + let (num_values, input_and_abi_values) = + input_and_abi_values.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?; + + let mut output_strings = Vec::new(); + let num_values = num_values[0].to_field().to_u128() as usize; + + let mut abi_types = Vec::new(); + for abi_values in input_and_abi_values.iter().skip(input_and_abi_values.len() - num_values) { + let abi_type = fetch_abi_type(abi_values)?; + abi_types.push(abi_type); + } + + for i in 0..num_values { + let abi_type = &abi_types[i]; + let type_size = abi_type.field_count() as usize; + + let mut input_values_as_fields = input_and_abi_values[i..(i + type_size)] + .iter() + .flat_map(|values| vecmap(values, |value| value.to_field())); + + let input_value_display = + InputValueDisplay::try_from_fields(&mut input_values_as_fields, abi_type.clone())?; + + output_strings.push(input_value_display.to_string()); + } + + let mut output_strings_iter = output_strings.into_iter(); + let re = Regex::new(r"\{([a-zA-Z0-9_]+)\}") + .expect("ICE: an invalid regex pattern was used for checking format strings"); + + let formatted_str = re.replace_all(&message_as_string, |_: &Captures| { + output_strings_iter + .next() + .expect("ICE: there are more regex matches than fields supplied to the format string") + }); + + Ok(formatted_str.into_owned()) +} + +fn fetch_abi_type(abi_type_as_values: &[Value]) -> Result { let abi_type_as_fields = vecmap(abi_type_as_values, |value| value.to_field()); let abi_type_as_string = decode_string_value(&abi_type_as_fields); let abi_type: AbiType = serde_json::from_str(&abi_type_as_string) .map_err(|err| ForeignCallError::InputParserError(err.into()))?; - Ok((abi_type, input_values)) + Ok(abi_type) } diff --git a/crates/nargo/src/package.rs b/crates/nargo/src/package.rs new file mode 100644 index 00000000000..20c662b69f4 --- /dev/null +++ b/crates/nargo/src/package.rs @@ -0,0 +1,33 @@ +use std::{collections::BTreeMap, path::PathBuf}; + +use noirc_frontend::graph::{CrateName, CrateType}; + +use crate::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE}; + +#[derive(Clone)] +pub enum Dependency { + Local { package: Package }, + Remote { package: Package }, +} + +#[derive(Clone)] +pub struct Package { + pub root_dir: PathBuf, + pub crate_type: CrateType, + pub entry_path: PathBuf, + pub name: CrateName, + pub dependencies: BTreeMap, +} + +impl Package { + pub fn prover_input_path(&self) -> PathBuf { + // TODO: This should be configurable, such as if we are looking for .json or .toml or custom paths + // For now it is hard-coded to be toml. + self.root_dir.join(format!("{PROVER_INPUT_FILE}.toml")) + } + pub fn verifier_input_path(&self) -> PathBuf { + // TODO: This should be configurable, such as if we are looking for .json or .toml or custom paths + // For now it is hard-coded to be toml. + self.root_dir.join(format!("{VERIFIER_INPUT_FILE}.toml")) + } +} diff --git a/crates/nargo/src/workspace.rs b/crates/nargo/src/workspace.rs index 0954b4eb143..5df13350683 100644 --- a/crates/nargo/src/workspace.rs +++ b/crates/nargo/src/workspace.rs @@ -2,3 +2,77 @@ // Then we use workspace to allow more than one. In the future, do not allow there to be // both a binary and a library. // - library will be default + +use std::{ + iter::{once, Once}, + path::PathBuf, + slice, +}; + +use crate::{ + constants::{CONTRACT_DIR, PROOFS_DIR, TARGET_DIR}, + package::Package, +}; + +#[derive(Clone)] +pub struct Workspace { + pub root_dir: PathBuf, + pub members: Vec, + // If `Some()`, the `selected_package_index` is used to select the only `Package` when iterating a Workspace + pub selected_package_index: Option, +} + +impl Workspace { + pub fn package_build_path(&self, package: &Package) -> PathBuf { + let name: String = package.name.clone().into(); + self.target_directory_path().join(name) + } + + pub fn contracts_directory_path(&self, package: &Package) -> PathBuf { + let name: String = package.name.clone().into(); + self.root_dir.join(CONTRACT_DIR).join(name) + } + + pub fn proofs_directory_path(&self) -> PathBuf { + self.root_dir.join(PROOFS_DIR) + } + + pub fn target_directory_path(&self) -> PathBuf { + self.root_dir.join(TARGET_DIR) + } +} + +pub enum IntoIter<'a, T> { + Only(Once<&'a T>), + All(slice::Iter<'a, T>), +} + +impl<'a> IntoIterator for &'a Workspace { + type Item = &'a Package; + type IntoIter = IntoIter<'a, Package>; + + fn into_iter(self) -> Self::IntoIter { + if let Some(index) = self.selected_package_index { + // Precondition: The selected_package_index was verified to be in-bounds before constructing workspace + let member = self + .members + .get(index) + .expect("Workspace constructed with invalid selected_package_index"); + + IntoIter::Only(once(member)) + } else { + IntoIter::All(self.members.iter()) + } + } +} + +impl<'a> Iterator for IntoIter<'a, Package> { + type Item = &'a Package; + + fn next(&mut self) -> Option { + match self { + Self::Only(iter) => iter.next(), + Self::All(iter) => iter.next(), + } + } +} diff --git a/crates/nargo_cli/build.rs b/crates/nargo_cli/build.rs index d889ba6856c..f3493148a7f 100644 --- a/crates/nargo_cli/build.rs +++ b/crates/nargo_cli/build.rs @@ -84,7 +84,6 @@ fn generate_tests(test_file: &mut File) { if config_data["exclude"].contains(&test_name) { "#[ignore]" } else { "" }; let should_fail = config_data["fail"].contains(&test_name); - let is_workspace = test_dir.to_str().map_or(false, |s| s.contains("workspace")); write!( test_file, @@ -96,8 +95,7 @@ fn execute_{test_sub_dir}_{test_name}() {{ let mut cmd = Command::cargo_bin("nargo").unwrap(); cmd.arg("--program-dir").arg(test_program_dir); - cmd.arg(if {is_workspace} {{ "test" }} else {{ "execute" }}); - + cmd.arg("execute"); if {should_fail} {{ cmd.assert().failure(); diff --git a/crates/nargo_cli/src/cli/check_cmd.rs b/crates/nargo_cli/src/cli/check_cmd.rs index 9a0a2f77e7c..8f2e23ed750 100644 --- a/crates/nargo_cli/src/cli/check_cmd.rs +++ b/crates/nargo_cli/src/cli/check_cmd.rs @@ -1,53 +1,58 @@ -use crate::{errors::CliError, resolver::resolve_root_manifest}; +use crate::{ + errors::CliError, find_package_manifest, manifest::resolve_workspace_from_toml, prepare_package, +}; use acvm::Backend; use clap::Args; use iter_extended::btree_map; +use nargo::package::Package; use noirc_abi::{AbiParameter, AbiType, MAIN_RETURN_NAME}; use noirc_driver::{check_crate, compute_function_signature, CompileOptions}; use noirc_errors::reporter::ReportedErrors; -use noirc_frontend::{graph::CrateId, hir::Context}; -use std::path::{Path, PathBuf}; +use noirc_frontend::{ + graph::{CrateId, CrateName}, + hir::Context, +}; use super::fs::write_to_file; use super::NargoConfig; -use crate::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE}; /// Checks the constraint system for errors #[derive(Debug, Clone, Args)] pub(crate) struct CheckCommand { + /// The name of the package to check + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } pub(crate) fn run( - backend: &B, + _backend: &B, args: CheckCommand, config: NargoConfig, ) -> Result<(), CliError> { - check_from_path(backend, &config.program_dir, &args.compile_options)?; - println!("Constraint system successfully built!"); + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + + for package in &workspace { + check_package(package, &args.compile_options)?; + println!("[{}] Constraint system successfully built!", package.name); + } Ok(()) } -fn check_from_path( - // Backend isn't used but keeping it in the signature allows for better type inference - // TODO: This function doesn't need to exist but requires a little more refactoring - _backend: &B, - program_dir: &Path, +fn check_package( + package: &Package, compile_options: &CompileOptions, -) -> Result<(), CliError> { - let (mut context, crate_id) = resolve_root_manifest(program_dir, None)?; +) -> Result<(), ReportedErrors> { + let (mut context, crate_id) = prepare_package(package); check_crate_and_report_errors(&mut context, crate_id, compile_options.deny_warnings)?; // XXX: We can have a --overwrite flag to determine if you want to overwrite the Prover/Verifier.toml files if let Some((parameters, return_type)) = compute_function_signature(&context, &crate_id) { - // XXX: The root config should return an enum to determine if we are looking for .json or .toml - // For now it is hard-coded to be toml. - // - // Check for input.toml and verifier.toml - let path_to_root = PathBuf::from(program_dir); - let path_to_prover_input = path_to_root.join(format!("{PROVER_INPUT_FILE}.toml")); - let path_to_verifier_input = path_to_root.join(format!("{VERIFIER_INPUT_FILE}.toml")); + let path_to_prover_input = package.prover_input_path(); + let path_to_verifier_input = package.verifier_input_path(); // If they are not available, then create them and populate them based on the ABI if !path_to_prover_input.exists() { @@ -108,6 +113,8 @@ mod tests { use noirc_abi::{AbiParameter, AbiType, AbiVisibility, Sign}; use noirc_driver::CompileOptions; + use crate::{find_package_manifest, manifest::resolve_workspace_from_toml}; + use super::create_input_toml_template; const TEST_DATA_DIR: &str = "tests/target_tests_data"; @@ -157,16 +164,15 @@ d2 = ["", "", ""] let pass_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("{TEST_DATA_DIR}/pass")); - let backend = crate::backends::ConcreteBackend::default(); let config = CompileOptions::default(); let paths = std::fs::read_dir(pass_dir).unwrap(); for path in paths.flatten() { let path = path.path(); - assert!( - super::check_from_path(&backend, &path, &config).is_ok(), - "path: {}", - path.display() - ); + let toml_path = find_package_manifest(&path).unwrap(); + let workspace = resolve_workspace_from_toml(&toml_path, None).unwrap(); + for package in &workspace { + assert!(super::check_package(package, &config).is_ok(), "path: {}", path.display()); + } } } @@ -176,16 +182,19 @@ d2 = ["", "", ""] let fail_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("{TEST_DATA_DIR}/fail")); - let backend = crate::backends::ConcreteBackend::default(); let config = CompileOptions::default(); let paths = std::fs::read_dir(fail_dir).unwrap(); for path in paths.flatten() { let path = path.path(); - assert!( - super::check_from_path(&backend, &path, &config).is_err(), - "path: {}", - path.display() - ); + let toml_path = find_package_manifest(&path).unwrap(); + let workspace = resolve_workspace_from_toml(&toml_path, None).unwrap(); + for package in &workspace { + assert!( + super::check_package(package, &config).is_err(), + "path: {}", + path.display() + ); + } } } @@ -194,17 +203,16 @@ d2 = ["", "", ""] let pass_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join(format!("{TEST_DATA_DIR}/pass_dev_mode")); - let backend = crate::backends::ConcreteBackend::default(); let config = CompileOptions { deny_warnings: false, ..Default::default() }; let paths = std::fs::read_dir(pass_dir).unwrap(); for path in paths.flatten() { let path = path.path(); - assert!( - super::check_from_path(&backend, &path, &config).is_ok(), - "path: {}", - path.display() - ); + let toml_path = find_package_manifest(&path).unwrap(); + let workspace = resolve_workspace_from_toml(&toml_path, None).unwrap(); + for package in &workspace { + assert!(super::check_package(package, &config).is_ok(), "path: {}", path.display()); + } } } } diff --git a/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs b/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs index cedf558bcb8..0c01f8d5dc8 100644 --- a/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs +++ b/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs @@ -1,3 +1,5 @@ +use std::path::PathBuf; + use super::fs::{ common_reference_string::{ read_cached_common_reference_string, update_common_reference_string, @@ -8,20 +10,23 @@ use super::fs::{ write_to_file, }; use super::NargoConfig; -use crate::{ - cli::compile_cmd::compile_circuit, constants::CONTRACT_DIR, constants::TARGET_DIR, - errors::CliError, -}; +use crate::{cli::compile_cmd::compile_circuit, errors::CliError}; +use crate::{find_package_manifest, manifest::resolve_workspace_from_toml, prepare_package}; use acvm::Backend; use clap::Args; -use nargo::ops::{codegen_verifier, preprocess_program}; +use nargo::{ + ops::{codegen_verifier, preprocess_program}, + package::Package, +}; use noirc_driver::CompileOptions; +use noirc_frontend::graph::CrateName; /// Generates a Solidity verifier smart contract for the program #[derive(Debug, Clone, Args)] pub(crate) struct CodegenVerifierCommand { - /// The name of the circuit build files (ACIR, proving and verification keys) - circuit_name: Option, + /// The name of the package to codegen + #[clap(long)] + package: Option, #[clap(flatten)] compile_options: CompileOptions, @@ -32,34 +37,52 @@ pub(crate) fn run( args: CodegenVerifierCommand, config: NargoConfig, ) -> Result<(), CliError> { - // TODO(#1201): Should this be a utility function? - let circuit_build_path = args - .circuit_name - .map(|circuit_name| config.program_dir.join(TARGET_DIR).join(circuit_name)); + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; - let common_reference_string = read_cached_common_reference_string(); + for package in &workspace { + let circuit_build_path = workspace.package_build_path(package); + + let smart_contract_string = smart_contract_for_package( + backend, + package, + circuit_build_path, + &args.compile_options, + )?; + + let contract_dir = workspace.contracts_directory_path(package); + create_named_dir(&contract_dir, "contract"); + let contract_path = contract_dir.join("plonk_vk").with_extension("sol"); + + let path = write_to_file(smart_contract_string.as_bytes(), &contract_path); + println!("[{}] Contract successfully created and located at {path}", package.name); + } - let (common_reference_string, preprocessed_program) = match circuit_build_path { - Some(circuit_build_path) => { - let program = read_program_from_file(circuit_build_path)?; - let common_reference_string = update_common_reference_string( - backend, - &common_reference_string, - &program.bytecode, - ) - .map_err(CliError::CommonReferenceStringError)?; - (common_reference_string, program) - } - None => { - let (program, _) = - compile_circuit(backend, None, config.program_dir.as_ref(), &args.compile_options)?; - let common_reference_string = - update_common_reference_string(backend, &common_reference_string, &program.circuit) - .map_err(CliError::CommonReferenceStringError)?; - let (program, _) = preprocess_program(backend, true, &common_reference_string, program) - .map_err(CliError::ProofSystemCompilerError)?; - (common_reference_string, program) - } + Ok(()) +} + +fn smart_contract_for_package( + backend: &B, + package: &Package, + circuit_build_path: PathBuf, + compile_options: &CompileOptions, +) -> Result> { + let common_reference_string = read_cached_common_reference_string(); + let (common_reference_string, preprocessed_program) = if circuit_build_path.exists() { + let program = read_program_from_file(circuit_build_path)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.bytecode) + .map_err(CliError::CommonReferenceStringError)?; + (common_reference_string, program) + } else { + let (mut context, crate_id) = prepare_package(package); + let program = compile_circuit(backend, &mut context, crate_id, compile_options)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.circuit) + .map_err(CliError::CommonReferenceStringError)?; + let (program, _) = preprocess_program(backend, true, &common_reference_string, program) + .map_err(CliError::ProofSystemCompilerError)?; + (common_reference_string, program) }; let verification_key = preprocessed_program @@ -75,11 +98,5 @@ pub(crate) fn run( write_cached_common_reference_string(&common_reference_string); - let contract_dir = config.program_dir.join(CONTRACT_DIR); - create_named_dir(&contract_dir, "contract"); - let contract_path = contract_dir.join("plonk_vk").with_extension("sol"); - - let path = write_to_file(smart_contract_string.as_bytes(), &contract_path); - println!("Contract successfully created and located at {path}"); - Ok(()) + Ok(smart_contract_string) } diff --git a/crates/nargo_cli/src/cli/compile_cmd.rs b/crates/nargo_cli/src/cli/compile_cmd.rs index fbaecb606a1..2d59667e7ff 100644 --- a/crates/nargo_cli/src/cli/compile_cmd.rs +++ b/crates/nargo_cli/src/cli/compile_cmd.rs @@ -7,14 +7,16 @@ use noirc_driver::{ compile_contracts, compile_main, CompileOptions, CompiledProgram, ErrorsAndWarnings, Warnings, }; use noirc_errors::reporter::ReportedErrors; +use noirc_frontend::graph::{CrateId, CrateName}; use noirc_frontend::hir::Context; -use std::path::Path; use clap::Args; use nargo::ops::{preprocess_contract_function, preprocess_program}; -use crate::{constants::TARGET_DIR, errors::CliError, resolver::resolve_root_manifest}; +use crate::errors::CliError; +use crate::manifest::resolve_workspace_from_toml; +use crate::{find_package_manifest, prepare_package}; use super::fs::{ common_reference_string::{ @@ -31,9 +33,6 @@ const BACKEND_IDENTIFIER: &str = "acvm-backend-barretenberg"; /// Compile the program and its secret execution trace into ACIR format #[derive(Debug, Clone, Args)] pub(crate) struct CompileCommand { - /// The name of the ACIR file - circuit_name: String, - /// Include Proving and Verification keys in the build artifacts. #[arg(long)] include_keys: bool, @@ -42,6 +41,10 @@ pub(crate) struct CompileCommand { #[arg(short, long)] contracts: bool, + /// The name of the package to compile + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } @@ -51,66 +54,72 @@ pub(crate) fn run( args: CompileCommand, config: NargoConfig, ) -> Result<(), CliError> { - let circuit_dir = config.program_dir.join(TARGET_DIR); + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + let circuit_dir = workspace.target_directory_path(); let mut common_reference_string = read_cached_common_reference_string(); // If contracts is set we're compiling every function in a 'contract' rather than just 'main'. if args.contracts { - let (mut context, crate_id) = resolve_root_manifest(&config.program_dir, None)?; - - let result = compile_contracts(&mut context, crate_id, &args.compile_options); - let contracts = report_errors(result, &context, args.compile_options.deny_warnings)?; - - // TODO(#1389): I wonder if it is incorrect for nargo-core to know anything about contracts. - // As can be seen here, It seems like a leaky abstraction where ContractFunctions (essentially CompiledPrograms) - // are compiled via nargo-core and then the PreprocessedContract is constructed here. - // This is due to EACH function needing it's own CRS, PKey, and VKey from the backend. - let preprocessed_contracts: Result, CliError> = - try_vecmap(contracts, |contract| { - let preprocessed_contract_functions = - try_vecmap(contract.functions, |mut func| { - func.bytecode = optimize_circuit(backend, func.bytecode)?.0; - common_reference_string = update_common_reference_string( - backend, - &common_reference_string, - &func.bytecode, - ) - .map_err(CliError::CommonReferenceStringError)?; - - preprocess_contract_function( - backend, - args.include_keys, - &common_reference_string, - func, - ) - .map_err(CliError::ProofSystemCompilerError) - })?; - - Ok(PreprocessedContract { - name: contract.name, - backend: String::from(BACKEND_IDENTIFIER), - functions: preprocessed_contract_functions, - }) - }); - for contract in preprocessed_contracts? { - save_contract_to_file( - &contract, - &format!("{}-{}", &args.circuit_name, contract.name), - &circuit_dir, - ); + for package in &workspace { + let (mut context, crate_id) = prepare_package(package); + let result = compile_contracts(&mut context, crate_id, &args.compile_options); + let contracts = report_errors(result, &context, args.compile_options.deny_warnings)?; + + // TODO(#1389): I wonder if it is incorrect for nargo-core to know anything about contracts. + // As can be seen here, It seems like a leaky abstraction where ContractFunctions (essentially CompiledPrograms) + // are compiled via nargo-core and then the PreprocessedContract is constructed here. + // This is due to EACH function needing it's own CRS, PKey, and VKey from the backend. + let preprocessed_contracts: Result, CliError> = + try_vecmap(contracts, |contract| { + let preprocessed_contract_functions = + try_vecmap(contract.functions, |mut func| { + func.bytecode = optimize_circuit(backend, func.bytecode)?.0; + common_reference_string = update_common_reference_string( + backend, + &common_reference_string, + &func.bytecode, + ) + .map_err(CliError::CommonReferenceStringError)?; + + preprocess_contract_function( + backend, + args.include_keys, + &common_reference_string, + func, + ) + .map_err(CliError::ProofSystemCompilerError) + })?; + + Ok(PreprocessedContract { + name: contract.name, + backend: String::from(BACKEND_IDENTIFIER), + functions: preprocessed_contract_functions, + }) + }); + for contract in preprocessed_contracts? { + save_contract_to_file( + &contract, + &format!("{}-{}", package.name, contract.name), + &circuit_dir, + ); + } } } else { - let (program, _) = - compile_circuit(backend, None, &config.program_dir, &args.compile_options)?; - common_reference_string = - update_common_reference_string(backend, &common_reference_string, &program.circuit) - .map_err(CliError::CommonReferenceStringError)?; - - let (preprocessed_program, _) = - preprocess_program(backend, args.include_keys, &common_reference_string, program) - .map_err(CliError::ProofSystemCompilerError)?; - save_program_to_file(&preprocessed_program, &args.circuit_name, circuit_dir); + for package in &workspace { + let (mut context, crate_id) = prepare_package(package); + let program = compile_circuit(backend, &mut context, crate_id, &args.compile_options)?; + + common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.circuit) + .map_err(CliError::CommonReferenceStringError)?; + + let (preprocessed_program, _) = + preprocess_program(backend, args.include_keys, &common_reference_string, program) + .map_err(CliError::ProofSystemCompilerError)?; + save_program_to_file(&preprocessed_program, &package.name, &circuit_dir); + } } write_cached_common_reference_string(&common_reference_string); @@ -120,18 +129,18 @@ pub(crate) fn run( pub(crate) fn compile_circuit( backend: &B, - package: Option, - program_dir: &Path, + context: &mut Context, + crate_id: CrateId, compile_options: &CompileOptions, -) -> Result<(CompiledProgram, Context), CliError> { - let (mut context, crate_id) = resolve_root_manifest(program_dir, package)?; - let result = compile_main(&mut context, crate_id, compile_options); - let mut program = report_errors(result, &context, compile_options.deny_warnings)?; - +) -> Result { + let result = compile_main(context, crate_id, compile_options); + let mut program = report_errors(result, context, compile_options.deny_warnings)?; // Apply backend specific optimizations. let (optimized_circuit, opcode_labels) = optimize_circuit(backend, program.circuit) .expect("Backend does not support an opcode that is in the IR"); + // TODO(#2110): Why does this set `program.circuit` to `optimized_circuit` instead of the function taking ownership + // and requiring we use `optimized_circuit` everywhere after program.circuit = optimized_circuit; let opcode_ids = vecmap(opcode_labels, |label| match label { OpcodeLabel::Unresolved => { @@ -141,7 +150,7 @@ pub(crate) fn compile_circuit( }); program.debug.update_acir(opcode_ids); - Ok((program, context)) + Ok(program) } pub(super) fn optimize_circuit( diff --git a/crates/nargo_cli/src/cli/execute_cmd.rs b/crates/nargo_cli/src/cli/execute_cmd.rs index eaaea6d4ab3..a2700caee0f 100644 --- a/crates/nargo_cli/src/cli/execute_cmd.rs +++ b/crates/nargo_cli/src/cli/execute_cmd.rs @@ -1,23 +1,23 @@ -use std::path::Path; - use acvm::acir::circuit::OpcodeLabel; use acvm::acir::{circuit::Circuit, native_types::WitnessMap}; use acvm::Backend; use clap::Args; +use nargo::constants::PROVER_INPUT_FILE; +use nargo::package::Package; use nargo::NargoError; use noirc_abi::input_parser::{Format, InputValue}; use noirc_abi::{Abi, InputMap}; use noirc_driver::{CompileOptions, CompiledProgram}; use noirc_errors::{debug_info::DebugInfo, CustomDiagnostic}; +use noirc_frontend::graph::CrateName; use noirc_frontend::hir::Context; +use super::compile_cmd::compile_circuit; use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir}; use super::NargoConfig; -use crate::{ - cli::compile_cmd::compile_circuit, - constants::{PROVER_INPUT_FILE, TARGET_DIR}, - errors::CliError, -}; +use crate::errors::CliError; +use crate::manifest::resolve_workspace_from_toml; +use crate::{find_package_manifest, prepare_package}; /// Executes a circuit to calculate its return value #[derive(Debug, Clone, Args)] @@ -29,6 +29,10 @@ pub(crate) struct ExecuteCommand { #[clap(long, short, default_value = PROVER_INPUT_FILE)] prover_name: String, + /// The name of the package to execute + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } @@ -38,35 +42,40 @@ pub(crate) fn run( args: ExecuteCommand, config: NargoConfig, ) -> Result<(), CliError> { - let (return_value, solved_witness) = - execute_with_path(backend, &config.program_dir, args.prover_name, &args.compile_options)?; + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + let witness_dir = &workspace.target_directory_path(); - println!("Circuit witness successfully solved"); - if let Some(return_value) = return_value { - println!("Circuit output: {return_value:?}"); - } - if let Some(witness_name) = args.witness_name { - let witness_dir = config.program_dir.join(TARGET_DIR); + for package in &workspace { + let (return_value, solved_witness) = + execute_package(backend, package, &args.prover_name, &args.compile_options)?; - let witness_path = save_witness_to_dir(solved_witness, &witness_name, witness_dir)?; + println!("[{}] Circuit witness successfully solved", package.name); + if let Some(return_value) = return_value { + println!("[{}] Circuit output: {return_value:?}", package.name); + } + if let Some(witness_name) = &args.witness_name { + let witness_path = save_witness_to_dir(solved_witness, witness_name, witness_dir)?; - println!("Witness saved to {}", witness_path.display()); + println!("[{}] Witness saved to {}", package.name, witness_path.display()); + } } Ok(()) } -fn execute_with_path( +fn execute_package( backend: &B, - program_dir: &Path, - prover_name: String, + package: &Package, + prover_name: &str, compile_options: &CompileOptions, ) -> Result<(Option, WitnessMap), CliError> { - let (compiled_program, context) = compile_circuit(backend, None, program_dir, compile_options)?; + let (mut context, crate_id) = prepare_package(package); + let compiled_program = compile_circuit(backend, &mut context, crate_id, compile_options)?; let CompiledProgram { abi, circuit, debug } = compiled_program; // Parse the initial witness values from Prover.toml let (inputs_map, _) = - read_inputs_from_file(program_dir, prover_name.as_str(), Format::Toml, &abi)?; + read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &abi)?; let solved_witness = execute_program(backend, circuit, &abi, &inputs_map, Some((debug, context)))?; @@ -123,7 +132,7 @@ pub(crate) fn execute_program( debug_data: Option<(DebugInfo, Context)>, ) -> Result> { let initial_witness = abi.encode(inputs_map, None)?; - let solved_witness_err = nargo::ops::execute_circuit(backend, circuit, initial_witness); + let solved_witness_err = nargo::ops::execute_circuit(backend, circuit, initial_witness, true); match solved_witness_err { Ok(solved_witness) => Ok(solved_witness), Err(err) => { diff --git a/crates/nargo_cli/src/cli/fs/inputs.rs b/crates/nargo_cli/src/cli/fs/inputs.rs index bd55e4b0abd..fd2afdefa12 100644 --- a/crates/nargo_cli/src/cli/fs/inputs.rs +++ b/crates/nargo_cli/src/cli/fs/inputs.rs @@ -70,6 +70,7 @@ mod tests { use std::{collections::BTreeMap, vec}; use acvm::FieldElement; + use nargo::constants::VERIFIER_INPUT_FILE; use noirc_abi::{ input_parser::{Format, InputValue}, Abi, AbiParameter, AbiType, AbiVisibility, @@ -77,7 +78,6 @@ mod tests { use tempdir::TempDir; use super::{read_inputs_from_file, write_inputs_to_file}; - use crate::constants::VERIFIER_INPUT_FILE; #[test] fn write_and_read_recovers_inputs_and_return_value() { diff --git a/crates/nargo_cli/src/cli/fs/program.rs b/crates/nargo_cli/src/cli/fs/program.rs index 871a6023837..311923a6686 100644 --- a/crates/nargo_cli/src/cli/fs/program.rs +++ b/crates/nargo_cli/src/cli/fs/program.rs @@ -1,6 +1,7 @@ use std::path::{Path, PathBuf}; use nargo::artifacts::{contract::PreprocessedContract, program::PreprocessedProgram}; +use noirc_frontend::graph::CrateName; use crate::errors::FilesystemError; @@ -8,10 +9,11 @@ use super::{create_named_dir, write_to_file}; pub(crate) fn save_program_to_file>( compiled_program: &PreprocessedProgram, - circuit_name: &str, + crate_name: &CrateName, circuit_dir: P, ) -> PathBuf { - save_build_artifact_to_file(compiled_program, circuit_name, circuit_dir) + let circuit_name: String = crate_name.into(); + save_build_artifact_to_file(compiled_program, &circuit_name, circuit_dir) } pub(crate) fn save_contract_to_file>( compiled_contract: &PreprocessedContract, diff --git a/crates/nargo_cli/src/cli/fs/proof.rs b/crates/nargo_cli/src/cli/fs/proof.rs index 3a54aa908f8..d2b3050708b 100644 --- a/crates/nargo_cli/src/cli/fs/proof.rs +++ b/crates/nargo_cli/src/cli/fs/proof.rs @@ -1,6 +1,8 @@ use std::path::{Path, PathBuf}; -use crate::{constants::PROOF_EXT, errors::FilesystemError}; +use nargo::constants::PROOF_EXT; + +use crate::errors::FilesystemError; use super::{create_named_dir, write_to_file}; diff --git a/crates/nargo_cli/src/cli/fs/witness.rs b/crates/nargo_cli/src/cli/fs/witness.rs index 7ecafb1615b..edfb1aa63d6 100644 --- a/crates/nargo_cli/src/cli/fs/witness.rs +++ b/crates/nargo_cli/src/cli/fs/witness.rs @@ -1,9 +1,10 @@ use std::path::{Path, PathBuf}; use acvm::acir::native_types::WitnessMap; +use nargo::constants::WITNESS_EXT; use super::{create_named_dir, write_to_file}; -use crate::{constants::WITNESS_EXT, errors::FilesystemError}; +use crate::errors::FilesystemError; pub(crate) fn save_witness_to_dir>( witnesses: WitnessMap, diff --git a/crates/nargo_cli/src/cli/info_cmd.rs b/crates/nargo_cli/src/cli/info_cmd.rs index 7ad0a2caf8c..1a834bdd78e 100644 --- a/crates/nargo_cli/src/cli/info_cmd.rs +++ b/crates/nargo_cli/src/cli/info_cmd.rs @@ -1,19 +1,27 @@ use acvm::Backend; use clap::Args; +use nargo::package::Package; use noirc_driver::CompileOptions; -use std::path::Path; +use noirc_frontend::graph::CrateName; -use crate::cli::compile_cmd::compile_circuit; -use crate::errors::CliError; +use crate::{ + cli::compile_cmd::compile_circuit, errors::CliError, find_package_manifest, + manifest::resolve_workspace_from_toml, prepare_package, +}; use super::NargoConfig; -/// Provides detailed informaton on a circuit +/// Provides detailed information on a circuit +/// /// Current information provided: /// 1. The number of ACIR opcodes /// 2. Counts the final number gates in the circuit used by a backend #[derive(Debug, Clone, Args)] pub(crate) struct InfoCommand { + /// The name of the package to detail + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } @@ -23,20 +31,29 @@ pub(crate) fn run( args: InfoCommand, config: NargoConfig, ) -> Result<(), CliError> { - count_opcodes_and_gates_with_path(backend, config.program_dir, &args.compile_options) + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + + for package in &workspace { + count_opcodes_and_gates_in_package(backend, package, &args.compile_options)?; + } + + Ok(()) } -fn count_opcodes_and_gates_with_path>( +fn count_opcodes_and_gates_in_package( backend: &B, - program_dir: P, + package: &Package, compile_options: &CompileOptions, ) -> Result<(), CliError> { - let (compiled_program, _) = - compile_circuit(backend, None, program_dir.as_ref(), compile_options)?; + let (mut context, crate_id) = prepare_package(package); + let compiled_program = compile_circuit(backend, &mut context, crate_id, compile_options)?; + let num_opcodes = compiled_program.circuit.opcodes.len(); println!( - "Total ACIR opcodes generated for language {:?}: {}", + "[{}] Total ACIR opcodes generated for language {:?}: {}", + package.name, backend.np_language(), num_opcodes ); @@ -44,7 +61,7 @@ fn count_opcodes_and_gates_with_path>( let exact_circuit_size = backend .get_exact_circuit_size(&compiled_program.circuit) .map_err(CliError::ProofSystemCompilerError)?; - println!("Backend circuit size: {exact_circuit_size}"); + println!("[{}] Backend circuit size: {exact_circuit_size}", package.name); Ok(()) } diff --git a/crates/nargo_cli/src/cli/init_cmd.rs b/crates/nargo_cli/src/cli/init_cmd.rs index 77613611343..a1d4576758a 100644 --- a/crates/nargo_cli/src/cli/init_cmd.rs +++ b/crates/nargo_cli/src/cli/init_cmd.rs @@ -1,17 +1,19 @@ -use crate::{ - constants::{PKG_FILE, SRC_DIR}, - errors::CliError, -}; +use crate::errors::CliError; use super::fs::{create_named_dir, write_to_file}; use super::{NargoConfig, CARGO_PKG_VERSION}; use acvm::Backend; use clap::Args; +use nargo::constants::{PKG_FILE, SRC_DIR}; use std::path::PathBuf; /// Create a Noir project in the current directory. #[derive(Debug, Clone, Args)] -pub(crate) struct InitCommand; +pub(crate) struct InitCommand { + /// Name of the package [default: current directory name] + #[clap(long)] + name: Option, +} const EXAMPLE: &str = r#"fn main(x : Field, y : pub Field) { assert(x != y); @@ -29,17 +31,20 @@ fn test_main() { pub(crate) fn run( // Backend is currently unused, but we might want to use it to inform the "new" template in the future _backend: &B, - _args: InitCommand, + args: InitCommand, config: NargoConfig, ) -> Result<(), CliError> { - initialize_project(config.program_dir); + let package_name = args + .name + .unwrap_or_else(|| config.program_dir.file_name().unwrap().to_str().unwrap().to_owned()); + + initialize_project(config.program_dir, &package_name); Ok(()) } /// Initializes a new Noir project in `package_dir`. -pub(crate) fn initialize_project(package_dir: PathBuf) { +pub(crate) fn initialize_project(package_dir: PathBuf, package_name: &str) { // TODO: Should this reject if we have non-Unicode filepaths? - let package_name = package_dir.file_name().expect("Expected a filename").to_string_lossy(); let src_dir = package_dir.join(SRC_DIR); create_named_dir(&src_dir, "src"); diff --git a/crates/nargo_cli/src/cli/lsp_cmd.rs b/crates/nargo_cli/src/cli/lsp_cmd.rs index afb824c5888..1a1028e2713 100644 --- a/crates/nargo_cli/src/cli/lsp_cmd.rs +++ b/crates/nargo_cli/src/cli/lsp_cmd.rs @@ -5,7 +5,6 @@ use async_lsp::{ }; use clap::Args; use noir_lsp::NargoLspService; -use noirc_driver::CompileOptions; use tokio::io::BufReader; use tower::ServiceBuilder; @@ -13,10 +12,7 @@ use super::NargoConfig; use crate::errors::CliError; #[derive(Debug, Clone, Args)] -pub(crate) struct LspCommand { - #[clap(flatten)] - compile_options: CompileOptions, -} +pub(crate) struct LspCommand; pub(crate) fn run( // Backend is currently unused, but we might want to use it to inform the lsp in the future diff --git a/crates/nargo_cli/src/cli/mod.rs b/crates/nargo_cli/src/cli/mod.rs index 8ce66db1b7b..9d494b21e6a 100644 --- a/crates/nargo_cli/src/cli/mod.rs +++ b/crates/nargo_cli/src/cli/mod.rs @@ -92,7 +92,7 @@ pub fn start_cli() -> eyre::Result<()> { #[cfg(test)] mod tests { use fm::FileManager; - use noirc_driver::{check_crate, create_local_crate}; + use noirc_driver::{check_crate, prepare_crate}; use noirc_errors::reporter; use noirc_frontend::{ graph::{CrateGraph, CrateType}, @@ -110,7 +110,7 @@ mod tests { let fm = FileManager::new(root_dir); let graph = CrateGraph::default(); let mut context = Context::new(fm, graph); - let crate_id = create_local_crate(&mut context, root_file, CrateType::Binary); + let crate_id = prepare_crate(&mut context, root_file, CrateType::Binary); let result = check_crate(&mut context, crate_id, false); let success = result.is_ok(); diff --git a/crates/nargo_cli/src/cli/new_cmd.rs b/crates/nargo_cli/src/cli/new_cmd.rs index 66c29eb3292..a792e752a51 100644 --- a/crates/nargo_cli/src/cli/new_cmd.rs +++ b/crates/nargo_cli/src/cli/new_cmd.rs @@ -8,10 +8,12 @@ use std::path::PathBuf; /// Create a Noir project in a new directory. #[derive(Debug, Clone, Args)] pub(crate) struct NewCommand { - /// Name of the package - package_name: String, /// The path to save the new project - path: Option, + path: PathBuf, + + /// Name of the package [default: package directory name] + #[clap(long)] + name: Option, } pub(crate) fn run( @@ -20,12 +22,14 @@ pub(crate) fn run( args: NewCommand, config: NargoConfig, ) -> Result<(), CliError> { - let package_dir = config.program_dir.join(args.package_name); + let package_dir = config.program_dir.join(&args.path); if package_dir.exists() { return Err(CliError::DestinationAlreadyExists(package_dir)); } - initialize_project(package_dir); + let package_name = + args.name.unwrap_or_else(|| args.path.file_name().unwrap().to_str().unwrap().to_owned()); + initialize_project(package_dir, &package_name); Ok(()) } diff --git a/crates/nargo_cli/src/cli/prove_cmd.rs b/crates/nargo_cli/src/cli/prove_cmd.rs index 92e9599cd8b..cdf83f9759b 100644 --- a/crates/nargo_cli/src/cli/prove_cmd.rs +++ b/crates/nargo_cli/src/cli/prove_cmd.rs @@ -3,38 +3,31 @@ use std::path::{Path, PathBuf}; use acvm::Backend; use clap::Args; use nargo::artifacts::program::PreprocessedProgram; +use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE}; use nargo::ops::{preprocess_program, prove_execution, verify_proof}; +use nargo::package::Package; use noirc_abi::input_parser::Format; use noirc_driver::CompileOptions; +use noirc_frontend::graph::CrateName; -use super::NargoConfig; -use super::{ - compile_cmd::compile_circuit, - fs::{ - common_reference_string::{ - read_cached_common_reference_string, update_common_reference_string, - write_cached_common_reference_string, - }, - inputs::{read_inputs_from_file, write_inputs_to_file}, - program::read_program_from_file, - proof::save_proof_to_dir, +use super::compile_cmd::compile_circuit; +use super::fs::{ + common_reference_string::{ + read_cached_common_reference_string, update_common_reference_string, + write_cached_common_reference_string, }, + inputs::{read_inputs_from_file, write_inputs_to_file}, + program::read_program_from_file, + proof::save_proof_to_dir, }; -use crate::{ - cli::execute_cmd::execute_program, - constants::{PROOFS_DIR, PROVER_INPUT_FILE, TARGET_DIR, VERIFIER_INPUT_FILE}, - errors::CliError, -}; +use super::NargoConfig; +use crate::manifest::resolve_workspace_from_toml; +use crate::{cli::execute_cmd::execute_program, errors::CliError}; +use crate::{find_package_manifest, prepare_package}; /// Create proof for this program. The proof is returned as a hex encoded string. #[derive(Debug, Clone, Args)] pub(crate) struct ProveCommand { - /// The name of the proof - proof_name: Option, - - /// The name of the circuit build files (ACIR, proving and verification keys) - circuit_name: Option, - /// The name of the toml file which contains the inputs for the prover #[clap(long, short, default_value = PROVER_INPUT_FILE)] prover_name: String, @@ -47,11 +40,12 @@ pub(crate) struct ProveCommand { #[arg(long)] verify: bool, + /// The name of the package to prove + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, - - #[clap(long)] - package: Option, } pub(crate) fn run( @@ -59,65 +53,57 @@ pub(crate) fn run( args: ProveCommand, config: NargoConfig, ) -> Result<(), CliError> { - let proof_dir = config.program_dir.join(PROOFS_DIR); - - let circuit_build_path = args - .circuit_name - .map(|circuit_name| config.program_dir.join(TARGET_DIR).join(circuit_name)); - - prove_with_path( - backend, - args.proof_name, - args.prover_name, - args.verifier_name, - args.package, - config.program_dir, - proof_dir, - circuit_build_path, - args.verify, - &args.compile_options, - )?; + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + let proof_dir = workspace.proofs_directory_path(); + + for package in &workspace { + let circuit_build_path = workspace.package_build_path(package); + + prove_package( + backend, + package, + &args.prover_name, + &args.verifier_name, + &proof_dir, + circuit_build_path, + args.verify, + &args.compile_options, + )?; + } Ok(()) } #[allow(clippy::too_many_arguments)] -pub(crate) fn prove_with_path>( +pub(crate) fn prove_package( backend: &B, - proof_name: Option, - prover_name: String, - verifier_name: String, - package: Option, - program_dir: P, - proof_dir: P, - circuit_build_path: Option, + package: &Package, + prover_name: &str, + verifier_name: &str, + proof_dir: &Path, + circuit_build_path: PathBuf, check_proof: bool, compile_options: &CompileOptions, -) -> Result, CliError> { +) -> Result<(), CliError> { let common_reference_string = read_cached_common_reference_string(); - let (common_reference_string, preprocessed_program, debug_data) = match circuit_build_path { - Some(circuit_build_path) => { - let program = read_program_from_file(circuit_build_path)?; - let common_reference_string = update_common_reference_string( - backend, - &common_reference_string, - &program.bytecode, - ) - .map_err(CliError::CommonReferenceStringError)?; - (common_reference_string, program, None) - } - None => { - let (program, context) = - compile_circuit(backend, package, program_dir.as_ref(), compile_options)?; - let common_reference_string = - update_common_reference_string(backend, &common_reference_string, &program.circuit) - .map_err(CliError::CommonReferenceStringError)?; - let (program, debug) = - preprocess_program(backend, true, &common_reference_string, program) - .map_err(CliError::ProofSystemCompilerError)?; - (common_reference_string, program, Some((debug, context))) - } + let (common_reference_string, preprocessed_program, debug_data) = if circuit_build_path.exists() + { + let program = read_program_from_file(circuit_build_path)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.bytecode) + .map_err(CliError::CommonReferenceStringError)?; + (common_reference_string, program, None) + } else { + let (mut context, crate_id) = prepare_package(package); + let program = compile_circuit(backend, &mut context, crate_id, compile_options)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.circuit) + .map_err(CliError::CommonReferenceStringError)?; + let (program, debug) = preprocess_program(backend, true, &common_reference_string, program) + .map_err(CliError::ProofSystemCompilerError)?; + (common_reference_string, program, Some((debug, context))) }; write_cached_common_reference_string(&common_reference_string); @@ -127,7 +113,7 @@ pub(crate) fn prove_with_path>( // Parse the initial witness values from Prover.toml let (inputs_map, _) = - read_inputs_from_file(&program_dir, prover_name.as_str(), Format::Toml, &abi)?; + read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &abi)?; let solved_witness = execute_program(backend, bytecode.clone(), &abi, &inputs_map, debug_data)?; @@ -139,8 +125,8 @@ pub(crate) fn prove_with_path>( &public_inputs, &return_value, &public_abi, - &program_dir, - verifier_name.as_str(), + &package.root_dir, + verifier_name, Format::Toml, )?; @@ -170,12 +156,7 @@ pub(crate) fn prove_with_path>( } } - let proof_path = if let Some(proof_name) = proof_name { - Some(save_proof_to_dir(&proof, &proof_name, proof_dir)?) - } else { - println!("{}", hex::encode(&proof)); - None - }; + save_proof_to_dir(&proof, &String::from(&package.name), proof_dir)?; - Ok(proof_path) + Ok(()) } diff --git a/crates/nargo_cli/src/cli/test_cmd.rs b/crates/nargo_cli/src/cli/test_cmd.rs index c1aa359e724..e52e3e5aa8d 100644 --- a/crates/nargo_cli/src/cli/test_cmd.rs +++ b/crates/nargo_cli/src/cli/test_cmd.rs @@ -1,15 +1,15 @@ -use std::{io::Write, path::Path}; +use std::io::Write; use acvm::{acir::native_types::WitnessMap, Backend}; use clap::Args; -use nargo::ops::execute_circuit; +use nargo::{ops::execute_circuit, package::Package}; use noirc_driver::{compile_no_check, CompileOptions}; -use noirc_frontend::{hir::Context, node_interner::FuncId}; +use noirc_frontend::{graph::CrateName, hir::Context, node_interner::FuncId}; use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; use crate::{ - cli::check_cmd::check_crate_and_report_errors, errors::CliError, - resolver::resolve_root_manifest, + cli::check_cmd::check_crate_and_report_errors, errors::CliError, find_package_manifest, + manifest::resolve_workspace_from_toml, prepare_package, }; use super::{compile_cmd::optimize_circuit, NargoConfig}; @@ -24,6 +24,10 @@ pub(crate) struct TestCommand { #[arg(long)] show_output: bool, + /// The name of the package to test + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } @@ -35,56 +39,62 @@ pub(crate) fn run( ) -> Result<(), CliError> { let test_name: String = args.test_name.unwrap_or_else(|| "".to_owned()); - run_tests(backend, &config.program_dir, &test_name, args.show_output, &args.compile_options) + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + + for package in &workspace { + run_tests(backend, package, &test_name, args.show_output, &args.compile_options)?; + } + + Ok(()) } fn run_tests( backend: &B, - program_dir: &Path, + package: &Package, test_name: &str, show_output: bool, compile_options: &CompileOptions, ) -> Result<(), CliError> { - let (mut context, crate_id) = resolve_root_manifest(program_dir, None)?; + let (mut context, crate_id) = prepare_package(package); check_crate_and_report_errors(&mut context, crate_id, compile_options.deny_warnings)?; - let test_functions = match context.crate_graph.crate_type(crate_id) { - noirc_frontend::graph::CrateType::Workspace => { - context.get_all_test_functions_in_workspace_matching(test_name) - } - _ => context.get_all_test_functions_in_crate_matching(&crate_id, test_name), - }; + let test_functions = context.get_all_test_functions_in_crate_matching(&crate_id, test_name); - println!("Running {} test functions...", test_functions.len()); + println!("[{}] Running {} test functions", package.name, test_functions.len()); let mut failing = 0; let writer = StandardStream::stderr(ColorChoice::Always); let mut writer = writer.lock(); for (test_name, test_function) in test_functions { - writeln!(writer, "Testing {test_name}...").expect("Failed to write to stdout"); - writer.flush().ok(); + write!(writer, "[{}] Testing {test_name}... ", package.name) + .expect("Failed to write to stdout"); + writer.flush().expect("Failed to flush writer"); match run_test(backend, &test_name, test_function, &context, show_output, compile_options) { Ok(_) => { - writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).ok(); - writeln!(writer, "ok").ok(); + writer + .set_color(ColorSpec::new().set_fg(Some(Color::Green))) + .expect("Failed to set color"); + writeln!(writer, "ok").expect("Failed to write to stdout"); } // Assume an error was already printed to stdout Err(_) => failing += 1, } - writer.reset().ok(); + writer.reset().expect("Failed to reset writer"); } if failing == 0 { - writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).unwrap(); - writeln!(writer, "All tests passed").ok(); + write!(writer, "[{}] ", package.name).expect("Failed to write to stdout"); + writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).expect("Failed to set color"); + writeln!(writer, "All tests passed").expect("Failed to write to stdout"); } else { let plural = if failing == 1 { "" } else { "s" }; - return Err(CliError::Generic(format!("{failing} test{plural} failed"))); + return Err(CliError::Generic(format!("[{}] {failing} test{plural} failed", package.name))); } - writer.reset().ok(); + writer.reset().expect("Failed to reset writer"); Ok(()) } @@ -96,14 +106,17 @@ fn run_test( show_output: bool, config: &CompileOptions, ) -> Result<(), CliError> { - let mut program = compile_no_check(context, show_output, config, main) - .map_err(|_| CliError::Generic(format!("Test '{test_name}' failed to compile")))?; + let mut program = compile_no_check(context, config, main).map_err(|err| { + noirc_errors::reporter::report_all(&context.file_manager, &[err], config.deny_warnings); + CliError::Generic(format!("Test '{test_name}' failed to compile")) + })?; + // Note: We could perform this test using the unoptimized ACIR as generated by `compile_no_check`. program.circuit = optimize_circuit(backend, program.circuit).unwrap().0; // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen, // otherwise constraints involving these expressions will not error. - match execute_circuit(backend, program.circuit, WitnessMap::new()) { + match execute_circuit(backend, program.circuit, WitnessMap::new(), show_output) { Ok(_) => Ok(()), Err(error) => { let writer = StandardStream::stderr(ColorChoice::Always); diff --git a/crates/nargo_cli/src/cli/verify_cmd.rs b/crates/nargo_cli/src/cli/verify_cmd.rs index f9068c66c9c..78b23a0612d 100644 --- a/crates/nargo_cli/src/cli/verify_cmd.rs +++ b/crates/nargo_cli/src/cli/verify_cmd.rs @@ -9,32 +9,31 @@ use super::fs::{ program::read_program_from_file, }; use super::NargoConfig; -use crate::{ - constants::{PROOFS_DIR, PROOF_EXT, TARGET_DIR, VERIFIER_INPUT_FILE}, - errors::CliError, -}; +use crate::errors::CliError; +use crate::manifest::resolve_workspace_from_toml; +use crate::{find_package_manifest, prepare_package}; use acvm::Backend; use clap::Args; -use nargo::artifacts::program::PreprocessedProgram; +use nargo::constants::{PROOF_EXT, VERIFIER_INPUT_FILE}; use nargo::ops::{preprocess_program, verify_proof}; +use nargo::{artifacts::program::PreprocessedProgram, package::Package}; use noirc_abi::input_parser::Format; use noirc_driver::CompileOptions; +use noirc_frontend::graph::CrateName; use std::path::{Path, PathBuf}; /// Given a proof and a program, verify whether the proof is valid #[derive(Debug, Clone, Args)] pub(crate) struct VerifyCommand { - /// The proof to verify - proof: String, - - /// The name of the circuit build files (ACIR, proving and verification keys) - circuit_name: Option, - /// The name of the toml file which contains the inputs for the verifier #[clap(long, short, default_value = VERIFIER_INPUT_FILE)] verifier_name: String, + /// The name of the package verify + #[clap(long)] + package: Option, + #[clap(flatten)] compile_options: CompileOptions, } @@ -44,54 +43,53 @@ pub(crate) fn run( args: VerifyCommand, config: NargoConfig, ) -> Result<(), CliError> { - let proof_path = - config.program_dir.join(PROOFS_DIR).join(&args.proof).with_extension(PROOF_EXT); - - let circuit_build_path = args - .circuit_name - .map(|circuit_name| config.program_dir.join(TARGET_DIR).join(circuit_name)); + let toml_path = find_package_manifest(&config.program_dir)?; + let workspace = resolve_workspace_from_toml(&toml_path, args.package)?; + let proofs_dir = workspace.proofs_directory_path(); + + for package in &workspace { + let circuit_build_path = workspace.package_build_path(package); + + let proof_path = proofs_dir.join(String::from(&package.name)).with_extension(PROOF_EXT); + + verify_package( + backend, + package, + &proof_path, + circuit_build_path, + &args.verifier_name, + &args.compile_options, + )?; + } - verify_with_path( - backend, - &config.program_dir, - proof_path, - circuit_build_path.as_ref(), - args.verifier_name, - &args.compile_options, - ) + Ok(()) } -fn verify_with_path>( +fn verify_package( backend: &B, - program_dir: P, - proof_path: PathBuf, - circuit_build_path: Option

, - verifier_name: String, + package: &Package, + proof_path: &Path, + circuit_build_path: PathBuf, + verifier_name: &str, compile_options: &CompileOptions, ) -> Result<(), CliError> { let common_reference_string = read_cached_common_reference_string(); - let (common_reference_string, preprocessed_program) = match circuit_build_path { - Some(circuit_build_path) => { - let program = read_program_from_file(circuit_build_path)?; - let common_reference_string = update_common_reference_string( - backend, - &common_reference_string, - &program.bytecode, - ) - .map_err(CliError::CommonReferenceStringError)?; - (common_reference_string, program) - } - None => { - let (program, _) = - compile_circuit(backend, None, program_dir.as_ref(), compile_options)?; - let common_reference_string = - update_common_reference_string(backend, &common_reference_string, &program.circuit) - .map_err(CliError::CommonReferenceStringError)?; - let (program, _) = preprocess_program(backend, true, &common_reference_string, program) - .map_err(CliError::ProofSystemCompilerError)?; - (common_reference_string, program) - } + let (common_reference_string, preprocessed_program) = if circuit_build_path.exists() { + let program = read_program_from_file(circuit_build_path)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.bytecode) + .map_err(CliError::CommonReferenceStringError)?; + (common_reference_string, program) + } else { + let (mut context, crate_id) = prepare_package(package); + let program = compile_circuit(backend, &mut context, crate_id, compile_options)?; + let common_reference_string = + update_common_reference_string(backend, &common_reference_string, &program.circuit) + .map_err(CliError::CommonReferenceStringError)?; + let (program, _) = preprocess_program(backend, true, &common_reference_string, program) + .map_err(CliError::ProofSystemCompilerError)?; + (common_reference_string, program) }; write_cached_common_reference_string(&common_reference_string); @@ -101,10 +99,10 @@ fn verify_with_path>( // Load public inputs (if any) from `verifier_name`. let public_abi = abi.public_abi(); let (public_inputs_map, return_value) = - read_inputs_from_file(program_dir, verifier_name.as_str(), Format::Toml, &public_abi)?; + read_inputs_from_file(&package.root_dir, verifier_name, Format::Toml, &public_abi)?; let public_inputs = public_abi.encode(&public_inputs_map, return_value)?; - let proof = load_hex_data(&proof_path)?; + let proof = load_hex_data(proof_path)?; let verification_key = verification_key .expect("Verification key should exist as `true` is passed to `preprocess_program`"); @@ -121,6 +119,6 @@ fn verify_with_path>( if valid_proof { Ok(()) } else { - Err(CliError::InvalidProof(proof_path)) + Err(CliError::InvalidProof(proof_path.to_path_buf())) } } diff --git a/crates/nargo_cli/src/errors.rs b/crates/nargo_cli/src/errors.rs index f9220d55b1c..00a84ff2964 100644 --- a/crates/nargo_cli/src/errors.rs +++ b/crates/nargo_cli/src/errors.rs @@ -9,8 +9,6 @@ use noirc_errors::reporter::ReportedErrors; use std::path::PathBuf; use thiserror::Error; -use crate::resolver::DependencyResolutionError; - #[derive(Debug, Error)] pub(crate) enum FilesystemError { #[error("Error: {} is not a valid path\nRun either `nargo compile` to generate missing build artifacts or `nargo prove` to construct a proof", .0.display())] @@ -41,9 +39,6 @@ pub(crate) enum CliError { #[error("Failed to verify proof {}", .0.display())] InvalidProof(PathBuf), - #[error(transparent)] - ResolutionError(#[from] DependencyResolutionError), - /// Errors encountered while compiling the noir program. /// These errors are already written to stderr. #[error("Aborting due to {} previous error{}", .0.error_count, if .0.error_count == 1 { "" } else { "s" })] @@ -64,6 +59,10 @@ pub(crate) enum CliError { #[error(transparent)] NargoError(#[from] NargoError), + /// Error from Manifest + #[error(transparent)] + ManifestError(#[from] ManifestError), + /// Backend error caused by a function on the SmartContract trait #[error(transparent)] SmartContractError(::Error), // Unfortunately, Rust won't let us `impl From` over an Associated Type on a generic @@ -82,3 +81,50 @@ impl From for CliError { Self::ReportedErrors(errors) } } + +/// Errors covering situations where a package is either missing or malformed. +#[derive(Debug, Error)] +pub(crate) enum ManifestError { + /// Package doesn't have a manifest file + #[error("cannot find a Nargo.toml in {}", .0.display())] + MissingFile(PathBuf), + + #[error("Cannot read file {0}. Does it exist?")] + ReadFailed(PathBuf), + + #[error("Nargo.toml is missing a parent directory")] + MissingParent, + + /// Package manifest is unreadable. + #[error("Nargo.toml is badly formed, could not parse.\n\n {0}")] + MalformedFile(#[from] toml::de::Error), + + #[error("Unxpected workspace definition found in {0}")] + UnexpectedWorkspace(PathBuf), + + /// Package does not contain Noir source files. + #[error("cannot find src directory in path {0}")] + NoSourceDir(PathBuf), + + /// Package has neither of `main.nr` and `lib.nr`. + #[error("package must contain either a `lib.nr`(Library) or a `main.nr`(Binary).")] + ContainsZeroCrates, + + /// Package has both a `main.nr` (for binaries) and `lib.nr` (for libraries) + #[error("package cannot contain both a `lib.nr` and a `main.nr`")] + ContainsMultipleCrates, + + /// Invalid character `-` in package name + #[error("invalid character `-` in package name")] + InvalidPackageName, + + /// Encountered error while downloading git repository. + #[error("{0}")] + GitError(String), + + #[error("Selected package ({0}) was not found")] + MissingSelectedPackage(String), + + #[error("Default package was not found. Does {0} exist in your workspace?")] + MissingDefaultPackage(PathBuf), +} diff --git a/crates/nargo_cli/src/git.rs b/crates/nargo_cli/src/git.rs index 7f103e21b38..850657a8af1 100644 --- a/crates/nargo_cli/src/git.rs +++ b/crates/nargo_cli/src/git.rs @@ -1,7 +1,16 @@ use std::path::PathBuf; +/// Creates a unique folder name for a GitHub repo +/// by using its URL and tag +fn resolve_folder_name(base: &url::Url, tag: &str) -> String { + let mut folder_name = base.domain().unwrap().to_owned(); + folder_name.push_str(base.path()); + folder_name.push_str(tag); + folder_name +} + pub(crate) fn git_dep_location(base: &url::Url, tag: &str) -> PathBuf { - let folder_name = super::resolver::resolve_folder_name(base, tag); + let folder_name = resolve_folder_name(base, tag); super::nargo_crates().join(folder_name) } diff --git a/crates/nargo_cli/src/lib.rs b/crates/nargo_cli/src/lib.rs index 9426decf194..05753f7f3d8 100644 --- a/crates/nargo_cli/src/lib.rs +++ b/crates/nargo_cli/src/lib.rs @@ -7,21 +7,26 @@ //! This name was used because it sounds like `cargo` and //! Noir Package Manager abbreviated is npm, which is already taken. -use noirc_frontend::graph::CrateType; +use fm::FileManager; +use nargo::package::{Dependency, Package}; +use noirc_driver::{add_dep, prepare_crate}; +use noirc_frontend::{ + graph::{CrateGraph, CrateId, CrateName, CrateType}, + hir::Context, +}; use std::{ + collections::BTreeMap, fs::ReadDir, path::{Path, PathBuf}, }; +use errors::ManifestError; + mod backends; pub mod cli; -mod constants; mod errors; mod git; mod manifest; -mod resolver; - -use nargo::manifest::InvalidPackageError; fn nargo_crates() -> PathBuf { dirs::home_dir().unwrap().join("nargo") @@ -30,7 +35,7 @@ fn nargo_crates() -> PathBuf { /// Returns the path of the root directory of the package containing `current_path`. /// /// Returns a `CliError` if no parent directories of `current_path` contain a manifest file. -fn find_package_root(current_path: &Path) -> Result { +fn find_package_root(current_path: &Path) -> Result { let manifest_path = find_package_manifest(current_path)?; let package_root = @@ -42,27 +47,27 @@ fn find_package_root(current_path: &Path) -> Result Result { +fn find_package_manifest(current_path: &Path) -> Result { current_path .ancestors() .find_map(|dir| find_file(dir, "Nargo", "toml")) - .ok_or_else(|| InvalidPackageError::MissingManifestFile(current_path.to_path_buf())) + .ok_or_else(|| ManifestError::MissingFile(current_path.to_path_buf())) } -fn lib_or_bin(current_path: impl AsRef) -> Result<(PathBuf, CrateType), InvalidPackageError> { - let current_path = current_path.as_ref(); +fn lib_or_bin(root_dir: impl AsRef) -> Result<(PathBuf, CrateType), ManifestError> { + let current_path = root_dir.as_ref(); // A library has a lib.nr and a binary has a main.nr // You cannot have both. let src_path = find_dir(current_path, "src") - .ok_or_else(|| InvalidPackageError::NoSourceDir(current_path.to_path_buf()))?; + .ok_or_else(|| ManifestError::NoSourceDir(current_path.to_path_buf()))?; let lib_nr_path = find_file(&src_path, "lib", "nr"); let bin_nr_path = find_file(&src_path, "main", "nr"); match (lib_nr_path, bin_nr_path) { - (Some(_), Some(_)) => Err(InvalidPackageError::ContainsMultipleCrates), + (Some(_), Some(_)) => Err(ManifestError::ContainsMultipleCrates), (None, Some(path)) => Ok((path, CrateType::Binary)), (Some(path), None) => Ok((path, CrateType::Library)), - (None, None) => Err(InvalidPackageError::ContainsZeroCrates), + (None, None) => Err(ManifestError::ContainsZeroCrates), } } @@ -93,3 +98,31 @@ fn find_artifact(entries: ReadDir, artifact_name: &str) -> Option { fn list_files_and_folders_in>(path: P) -> Option { std::fs::read_dir(path).ok() } + +fn prepare_dependencies( + context: &mut Context, + parent_crate: CrateId, + dependencies: BTreeMap, +) { + for (dep_name, dep) in dependencies.into_iter() { + match dep { + Dependency::Remote { package } | Dependency::Local { package } => { + let crate_id = prepare_crate(context, &package.entry_path, package.crate_type); + add_dep(context, parent_crate, crate_id, dep_name); + prepare_dependencies(context, crate_id, package.dependencies.to_owned()); + } + } + } +} + +fn prepare_package(package: &Package) -> (Context, CrateId) { + let fm = FileManager::new(&package.root_dir); + let graph = CrateGraph::default(); + let mut context = Context::new(fm, graph); + + let crate_id = prepare_crate(&mut context, &package.entry_path, package.crate_type); + + prepare_dependencies(&mut context, crate_id, package.dependencies.to_owned()); + + (context, crate_id) +} diff --git a/crates/nargo_cli/src/main.rs b/crates/nargo_cli/src/main.rs index a73785c64c6..a79c43dad48 100644 --- a/crates/nargo_cli/src/main.rs +++ b/crates/nargo_cli/src/main.rs @@ -3,12 +3,12 @@ use color_eyre::{config::HookBuilder, eyre}; use nargo_cli::cli::start_cli; +const PANIC_MESSAGE: &str = "This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml"; + fn main() -> eyre::Result<()> { // Register a panic hook to display more readable panic messages to end-users - let (panic_hook, _) = HookBuilder::default() - .display_env_section(false) - .panic_section("This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml") - .into_hooks(); + let (panic_hook, _) = + HookBuilder::default().display_env_section(false).panic_section(PANIC_MESSAGE).into_hooks(); panic_hook.install(); start_cli() diff --git a/crates/nargo_cli/src/manifest.rs b/crates/nargo_cli/src/manifest.rs index 2660fd8c1cb..e1da57c0c2b 100644 --- a/crates/nargo_cli/src/manifest.rs +++ b/crates/nargo_cli/src/manifest.rs @@ -1,13 +1,284 @@ -use std::path::Path; +use std::{ + collections::BTreeMap, + path::{Path, PathBuf}, +}; -use nargo::manifest::{InvalidPackageError, Manifest}; +use nargo::{ + package::{Dependency, Package}, + workspace::Workspace, +}; +use noirc_frontend::graph::CrateName; +use serde::Deserialize; -/// Parses a Nargo.toml file from it's path -/// The path to the toml file must be present. -/// Calling this function without this guarantee is an ICE. -pub(crate) fn parse>(path_to_toml: P) -> Result { - let toml_as_string = - std::fs::read_to_string(&path_to_toml).expect("ice: path given for toml file is invalid"); +use crate::{errors::ManifestError, git::clone_git_repo}; - Manifest::from_toml_str(&toml_as_string) +#[derive(Debug, Deserialize, Clone)] +struct PackageConfig { + package: PackageMetadata, + dependencies: BTreeMap, +} + +impl PackageConfig { + fn resolve_to_package(&self, root_dir: &Path) -> Result { + let name = self.package.name.parse().map_err(|_| ManifestError::InvalidPackageName)?; + + let mut dependencies: BTreeMap = BTreeMap::new(); + for (name, dep_config) in self.dependencies.iter() { + let name = name.parse().map_err(|_| ManifestError::InvalidPackageName)?; + let resolved_dep = dep_config.resolve_to_dependency(root_dir)?; + + dependencies.insert(name, resolved_dep); + } + + let (entry_path, crate_type) = crate::lib_or_bin(root_dir)?; + + Ok(Package { root_dir: root_dir.to_path_buf(), entry_path, crate_type, name, dependencies }) + } +} + +/// Contains all the information about a package, as loaded from a `Nargo.toml`. +#[derive(Debug, Deserialize, Clone)] +#[serde(untagged)] +enum Config { + /// Represents a `Nargo.toml` with package fields. + Package { + #[serde(flatten)] + package_config: PackageConfig, + }, + /// Represents a `Nargo.toml` with workspace fields. + Workspace { + #[serde(alias = "workspace")] + workspace_config: WorkspaceConfig, + }, +} + +impl TryFrom for Config { + type Error = toml::de::Error; + + fn try_from(toml: String) -> Result { + toml::from_str(&toml) + } +} + +impl TryFrom<&str> for Config { + type Error = toml::de::Error; + + fn try_from(toml: &str) -> Result { + toml::from_str(toml) + } +} + +/// Tracks the root_dir of a `Nargo.toml` and the contents inside the file. +struct NargoToml { + root_dir: PathBuf, + config: Config, +} + +#[derive(Default, Debug, Deserialize, Clone)] +#[serde(rename_all = "kebab-case")] +struct WorkspaceConfig { + /// List of members in this workspace. + members: Vec, + /// Specifies the default crate to interact with in the context (similarly to how we have nargo as the default crate in this repository). + default_member: Option, +} + +#[allow(dead_code)] +#[derive(Default, Debug, Deserialize, Clone)] +struct PackageMetadata { + #[serde(default = "panic_missing_name")] + name: String, + description: Option, + authors: Option>, + // If not compiler version is supplied, the latest is used + // For now, we state that all packages must be compiled under the same + // compiler version. + // We also state that ACIR and the compiler will upgrade in lockstep. + // so you will not need to supply an ACIR and compiler version + compiler_version: Option, + backend: Option, + license: Option, +} + +// TODO: Remove this after a couple of breaking releases (added in 0.10.0) +fn panic_missing_name() -> String { + panic!( + r#" + +Failed to parse `Nargo.toml`. + +`Nargo.toml` now requires a "name" field for Noir packages. + +```toml +[package] +name = "package_name" +``` + +Modify your `Nargo.toml` similarly to above and rerun the command. + +"# + ) +} + +#[derive(Debug, Deserialize, Clone)] +#[serde(untagged)] +/// Enum representing the different types of ways to +/// supply a source for the dependency +enum DependencyConfig { + Github { git: String, tag: String }, + Path { path: String }, +} + +impl DependencyConfig { + fn resolve_to_dependency(&self, pkg_root: &Path) -> Result { + match self { + Self::Github { git, tag } => { + let dir_path = clone_git_repo(git, tag).map_err(ManifestError::GitError)?; + let toml_path = dir_path.join("Nargo.toml"); + let package = resolve_package_from_toml(&toml_path)?; + Ok(Dependency::Remote { package }) + } + Self::Path { path } => { + let dir_path = pkg_root.join(path); + let toml_path = dir_path.join("Nargo.toml"); + let package = resolve_package_from_toml(&toml_path)?; + Ok(Dependency::Local { package }) + } + } + } +} + +fn toml_to_workspace( + nargo_toml: NargoToml, + selected_package: Option, +) -> Result { + let workspace = match nargo_toml.config { + Config::Package { package_config } => { + let member = package_config.resolve_to_package(&nargo_toml.root_dir)?; + if selected_package.is_none() || Some(&member.name) == selected_package.as_ref() { + Workspace { + root_dir: nargo_toml.root_dir, + selected_package_index: Some(0), + members: vec![member], + } + } else { + return Err(ManifestError::MissingSelectedPackage(member.name.into())); + } + } + Config::Workspace { workspace_config } => { + let mut members = Vec::new(); + let mut selected_package_index = None; + for (index, member_path) in workspace_config.members.into_iter().enumerate() { + let package_root_dir = nargo_toml.root_dir.join(&member_path); + let package_toml_path = package_root_dir.join("Nargo.toml"); + let member = resolve_package_from_toml(&package_toml_path)?; + + match selected_package.as_ref() { + Some(selected_name) => { + if &member.name == selected_name { + selected_package_index = Some(index); + } + } + None => { + if Some(&member_path) == workspace_config.default_member.as_ref() { + selected_package_index = Some(index); + } + } + } + + members.push(member); + } + + // If the selected_package_index is still `None` but we have see a default_member or selected package, + // we want to present an error to users + if selected_package_index.is_none() { + if let Some(selected_name) = selected_package { + return Err(ManifestError::MissingSelectedPackage(selected_name.into())); + } + if let Some(default_path) = workspace_config.default_member { + return Err(ManifestError::MissingDefaultPackage(default_path)); + } + } + + Workspace { root_dir: nargo_toml.root_dir, members, selected_package_index } + } + }; + + Ok(workspace) +} + +fn read_toml(toml_path: &Path) -> Result { + let toml_as_string = std::fs::read_to_string(toml_path) + .map_err(|_| ManifestError::ReadFailed(toml_path.to_path_buf()))?; + let root_dir = toml_path.parent().ok_or(ManifestError::MissingParent)?; + let nargo_toml = + NargoToml { root_dir: root_dir.to_path_buf(), config: toml_as_string.try_into()? }; + + Ok(nargo_toml) +} + +/// Resolves a Nargo.toml file into a `Package` struct as defined by our `nargo` core. +fn resolve_package_from_toml(toml_path: &Path) -> Result { + let nargo_toml = read_toml(toml_path)?; + + match nargo_toml.config { + Config::Package { package_config } => { + package_config.resolve_to_package(&nargo_toml.root_dir) + } + Config::Workspace { .. } => { + Err(ManifestError::UnexpectedWorkspace(toml_path.to_path_buf())) + } + } +} + +/// Resolves a Nargo.toml file into a `Workspace` struct as defined by our `nargo` core. +pub(crate) fn resolve_workspace_from_toml( + toml_path: &Path, + selected_package: Option, +) -> Result { + let nargo_toml = read_toml(toml_path)?; + + toml_to_workspace(nargo_toml, selected_package) +} + +#[test] +fn parse_standard_toml() { + let src = r#" + + [package] + name = "test" + authors = ["kev", "foo"] + compiler_version = "0.1" + + [dependencies] + rand = { tag = "next", git = "https://github.com/rust-lang-nursery/rand"} + cool = { tag = "next", git = "https://github.com/rust-lang-nursery/rand"} + hello = {path = "./noir_driver"} + "#; + + assert!(Config::try_from(String::from(src)).is_ok()); + assert!(Config::try_from(src).is_ok()); +} + +#[test] +fn parse_workspace_toml() { + let src = r#" + [workspace] + members = ["a", "b"] + "#; + + assert!(Config::try_from(String::from(src)).is_ok()); + assert!(Config::try_from(src).is_ok()); +} + +#[test] +fn parse_workspace_default_member_toml() { + let src = r#" + [workspace] + members = ["a", "b"] + default-member = "a" + "#; + + assert!(Config::try_from(String::from(src)).is_ok()); + assert!(Config::try_from(src).is_ok()); } diff --git a/crates/nargo_cli/src/resolver.rs b/crates/nargo_cli/src/resolver.rs deleted file mode 100644 index 5c4e8225ee4..00000000000 --- a/crates/nargo_cli/src/resolver.rs +++ /dev/null @@ -1,265 +0,0 @@ -use std::{ - collections::HashMap, - path::{Path, PathBuf}, -}; - -use fm::FileManager; -use nargo::manifest::{Dependency, Manifest, PackageManifest, WorkspaceConfig}; -use noirc_driver::{add_dep, create_local_crate, create_non_local_crate}; -use noirc_frontend::{ - graph::{CrateGraph, CrateId, CrateName, CrateType}, - hir::Context, -}; -use thiserror::Error; - -use crate::{git::clone_git_repo, InvalidPackageError}; - -/// Creates a unique folder name for a GitHub repo -/// by using it's URL and tag -pub(crate) fn resolve_folder_name(base: &url::Url, tag: &str) -> String { - let mut folder_name = base.domain().unwrap().to_owned(); - folder_name.push_str(base.path()); - folder_name.push_str(tag); - folder_name -} - -/// Errors covering situations where a crate's dependency tree cannot be resolved. -#[derive(Debug, Error)] -pub(crate) enum DependencyResolutionError { - /// Encountered error while downloading git repository. - #[error("{0}")] - GitError(String), - - /// Attempted to depend on a binary crate. - #[error("dependency {dep_pkg_name} is a binary package and so it cannot be depended upon.")] - BinaryDependency { dep_pkg_name: String }, - - /// Attempted to depend on remote crate which has a local dependency. - /// We have no guarantees that this local dependency will be available so must error. - #[error("remote(git) dependency has a local dependency.\ndependency located at {}", dependency_path.display())] - RemoteDepWithLocalDep { dependency_path: PathBuf }, - - /// Dependency is not a valid crate - #[error(transparent)] - MalformedDependency(#[from] InvalidPackageError), - - /// Workspace does not contain packages - #[error("manifest path `{}` contains no packages", path.display())] - EmptyWorkspace { path: PathBuf }, - - /// Use workspace as a dependency is not currently supported - #[error("use workspace as a dependency is not currently supported")] - WorkspaceDependency, - - /// Multiple workspace roots found in the same workspace - #[error("multiple workspace roots found in the same workspace:\n{}\n{}", root.display(), member.display())] - MultipleWorkspace { root: PathBuf, member: PathBuf }, - - /// Invalid character `-` in package name - #[error("invalid character `-` in package name")] - InvalidPackageName, - - #[error("package specification `{0}` did not match any packages")] - PackageNotFound(String), - - #[error("two packages named `{0}` in this workspace")] - PackageCollision(String), -} - -#[derive(Debug, Clone)] -struct CachedDep { - entry_path: PathBuf, - crate_type: CrateType, - manifest: PackageManifest, - // Whether the dependency came from - // a remote dependency - remote: bool, -} - -/// Resolves a toml file by either downloading the necessary git repo -/// or it uses the repo on the cache. -/// Downloading will be recursive, so if a package contains packages -/// We need to download those too - -/// Returns the Driver and the backend to use -/// Note that the backend is ignored in the dependencies. -/// Since Noir is backend agnostic, this is okay to do. -/// XXX: Need to handle when a local package changes! -pub(crate) fn resolve_root_manifest( - dir_path: &std::path::Path, - package: Option, -) -> Result<(Context, CrateId), DependencyResolutionError> { - let fm = FileManager::new(dir_path); - let graph = CrateGraph::default(); - let mut context = Context::new(fm, graph); - - let manifest_path = super::find_package_manifest(dir_path)?; - let manifest = super::manifest::parse(&manifest_path)?; - - let crate_id = match manifest { - Manifest::Package(package) => { - let (entry_path, crate_type) = super::lib_or_bin(dir_path)?; - - let crate_id = create_local_crate(&mut context, &entry_path, crate_type); - let pkg_root = manifest_path.parent().expect("Every manifest path has a parent."); - - resolve_package_manifest(&mut context, crate_id, package, pkg_root)?; - - crate_id - } - Manifest::Workspace(workspace) => resolve_workspace_manifest( - &mut context, - package, - manifest_path, - dir_path, - workspace.config, - )?, - }; - - Ok((context, crate_id)) -} - -// Resolves a config file by recursively resolving the dependencies in the config -// Need to solve the case of a project trying to use itself as a dep -// -// We do not need to add stdlib, as it's implicitly -// imported. However, it may be helpful to have the stdlib imported by the -// package manager. -fn resolve_package_manifest( - context: &mut Context, - parent_crate: CrateId, - manifest: PackageManifest, - pkg_root: &Path, -) -> Result<(), DependencyResolutionError> { - let mut cached_packages: HashMap = HashMap::new(); - - // First download and add these top level dependencies crates to the Driver - for (dep_pkg_name, pkg_src) in manifest.dependencies.iter() { - let (dir_path, dep_meta) = cache_dep(pkg_src, pkg_root)?; - - let (entry_path, crate_type) = (&dep_meta.entry_path, &dep_meta.crate_type); - - if crate_type == &CrateType::Binary { - return Err(DependencyResolutionError::BinaryDependency { - dep_pkg_name: dep_pkg_name.to_string(), - }); - } - - let crate_id = create_non_local_crate(context, entry_path, *crate_type); - add_dep(context, parent_crate, crate_id, dep_pkg_name); - - cached_packages.insert(dir_path, (crate_id, dep_meta)); - } - - // Resolve all transitive dependencies - for (dependency_path, (crate_id, dep_meta)) in cached_packages { - if dep_meta.remote && dep_meta.manifest.has_local_dependency() { - return Err(DependencyResolutionError::RemoteDepWithLocalDep { dependency_path }); - } - // TODO: Why did it create a new resolver? - resolve_package_manifest(context, crate_id, dep_meta.manifest, &dependency_path)?; - } - Ok(()) -} - -fn resolve_workspace_manifest( - context: &mut Context, - mut local_package: Option, - manifest_path: PathBuf, - dir_path: &Path, - workspace: WorkspaceConfig, -) -> Result { - let members = workspace.members; - let mut packages = HashMap::new(); - - if members.is_empty() { - return Err(DependencyResolutionError::EmptyWorkspace { path: manifest_path }); - } - - for member in &members { - let member_path: PathBuf = dir_path.join(member); - let member_member_path = super::find_package_manifest(&member_path)?; - let member_manifest = super::manifest::parse(&member_member_path)?; - - match member_manifest { - Manifest::Package(inner) => { - let name: CrateName = inner - .package - .name - .parse() - .map_err(|_name| DependencyResolutionError::InvalidPackageName)?; - - if packages.insert(name.clone(), member_path).is_some() { - return Err(DependencyResolutionError::PackageCollision(name.into())); - } - - if local_package.is_none() && workspace.default_member.as_ref() == Some(member) { - local_package = Some(name.into()); - } - } - Manifest::Workspace(_) => { - return Err(DependencyResolutionError::MultipleWorkspace { - root: manifest_path, - member: member_member_path, - }) - } - } - } - - let local_package = match local_package { - Some(local_package) => { - local_package.parse().map_err(|_| DependencyResolutionError::InvalidPackageName)? - } - None => packages.keys().last().expect("non-empty packages").clone(), - }; - - let local_crate = packages - .remove(&local_package) - .ok_or_else(|| DependencyResolutionError::PackageNotFound(local_package.into()))?; - - let (entry_path, _crate_type) = super::lib_or_bin(local_crate)?; - let crate_id = create_local_crate(context, &entry_path, CrateType::Workspace); - - for (_, package_path) in packages.drain() { - let (entry_path, crate_type) = super::lib_or_bin(package_path)?; - create_non_local_crate(context, &entry_path, crate_type); - } - - Ok(crate_id) -} - -/// If the dependency is remote, download the dependency -/// and return the directory path along with the metadata -/// Needed to fill the CachedDep struct -/// -/// If it's a local path, the same applies, however it will not -/// be downloaded -fn cache_dep( - dep: &Dependency, - pkg_root: &Path, -) -> Result<(PathBuf, CachedDep), DependencyResolutionError> { - fn retrieve_meta( - dir_path: &Path, - remote: bool, - ) -> Result { - let (entry_path, crate_type) = super::lib_or_bin(dir_path)?; - let manifest_path = super::find_package_manifest(dir_path)?; - let manifest = super::manifest::parse(manifest_path)? - .to_package() - .ok_or(DependencyResolutionError::WorkspaceDependency)?; - Ok(CachedDep { entry_path, crate_type, manifest, remote }) - } - - match dep { - Dependency::Github { git, tag } => { - let dir_path = clone_git_repo(git, tag).map_err(DependencyResolutionError::GitError)?; - let meta = retrieve_meta(&dir_path, true)?; - Ok((dir_path, meta)) - } - Dependency::Path { path } => { - let dir_path = pkg_root.join(path); - let meta = retrieve_meta(&dir_path, false)?; - Ok((dir_path, meta)) - } - } -} diff --git a/crates/nargo_cli/tests/codegen-verifier.rs b/crates/nargo_cli/tests/codegen-verifier.rs index 3e4dc1dc745..f991f72b108 100644 --- a/crates/nargo_cli/tests/codegen-verifier.rs +++ b/crates/nargo_cli/tests/codegen-verifier.rs @@ -29,5 +29,9 @@ fn simple_verifier_codegen() { .success() .stdout(predicate::str::contains("Contract successfully created and located at")); - project_dir.child("contract").child("plonk_vk.sol").assert(predicate::path::is_file()); + project_dir + .child("contract") + .child("hello_world") + .child("plonk_vk.sol") + .assert(predicate::path::is_file()); } diff --git a/crates/nargo_cli/tests/hello_world.rs b/crates/nargo_cli/tests/hello_world.rs index 121f09f0ece..bc7022d1567 100644 --- a/crates/nargo_cli/tests/hello_world.rs +++ b/crates/nargo_cli/tests/hello_world.rs @@ -36,21 +36,20 @@ fn hello_world_example() { project_dir.child("Prover.toml").assert(predicate::path::is_file()); project_dir.child("Verifier.toml").assert(predicate::path::is_file()); - // `nargo prove p` - let proof_name = "p"; + // `nargo prove` project_dir.child("Prover.toml").write_str("x = 1\ny = 2").unwrap(); let mut cmd = Command::cargo_bin("nargo").unwrap(); - cmd.arg("prove").arg(proof_name); + cmd.arg("prove"); cmd.assert().success(); project_dir .child("proofs") - .child(format!("{proof_name}.proof")) + .child(format!("{project_name}.proof")) .assert(predicate::path::is_file()); // `nargo verify p` let mut cmd = Command::cargo_bin("nargo").unwrap(); - cmd.arg("verify").arg(proof_name); + cmd.arg("verify"); cmd.assert().success(); } diff --git a/crates/nargo_cli/tests/test_data/1327_concrete_in_generic/target/main.json b/crates/nargo_cli/tests/test_data/1327_concrete_in_generic/target/1327_concrete_in_generic.json similarity index 100% rename from crates/nargo_cli/tests/test_data/1327_concrete_in_generic/target/main.json rename to crates/nargo_cli/tests/test_data/1327_concrete_in_generic/target/1327_concrete_in_generic.json diff --git a/crates/nargo_cli/tests/test_data/1_mul/target/1_mul.json b/crates/nargo_cli/tests/test_data/1_mul/target/1_mul.json new file mode 100644 index 00000000000..f7d824175a6 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/1_mul/target/1_mul.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2Z326CMBTGP2SIyCTLsmw3u+ARWv5ouZuPMjN8/0fYyFo5MHbFV6KJJyG1jf16/vT8NPoG4B2/Fvw8KzvmYr4azUM7D+0Dsb+zDzuqeabdeeDqKkzYTG3tUftyhszFgx0jsZbY0dWss7WoTSj2HsW+QIyB0DiKPVPvCf7RScSa258JX8DLiVqDfu9UJjTZDl8udVeEHH1TRXYO+GuksW6p9lXVHopWl/pTFc3J1KqqT3ujja5N/VWYsmxNZQ7NqTmoRldlq891U56t8BP8NGXI8bOwfuoHYswRsS7M/PmGcYQhbFh+Y8Jmai8OYwe2WKzdYczRXATGneM5ehjH8Adj10hsGD/jNmC8JsYcE+vCzJ9vGMcYwoblNyZspvbiMN7YUYLvDmOO5iIw7gqYo4dxAn8wdo3EhvELbgPGG2LMCbEuzPz5hnGCYWOz/MaEzdReHMZbO6Zi7Q5jjuYiMO4KmKOHcQp/MHaNxIbxK24DxltizCmxLleev0vMITHmlOjXI7gfZn+aHvxeZPos/d2J1+437NXEnfAATI3ROeM8egWqryLtPOhm4F1+X3Fn/BoN4HTNOZXfdtwfcmP7BvHx78jZGwAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/1_mul/target/main.json b/crates/nargo_cli/tests/test_data/1_mul/target/main.json deleted file mode 100644 index 632c0e6b6a0..00000000000 --- a/crates/nargo_cli/tests/test_data/1_mul/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9WYTW6DMBSEJwESGhrapNsuOIKNIZhdr1JUcv8jFFQ7UCu7zEPBEjKW4P3MvI8FHwA+8bc2w7V1ezE7b4Nz5M7+2Y17/8vt6rGlfR5w4yoE68G42t/EQ4xkpgO78JsgcWBE4s4QNCGMa9Slqvqm7LXR36psO1urqu4uVltd2/qntMb0trJN27WNanVlen2tW3N1gXeQMTTi1Fm6OnVM7Dkh+sLUTwrgxM0mmQMxgPdDjBQLADwmKjABnEIOYG8CG+AXrAPgPbHnlOgLUz8pgFM3m2QOxAA+DDEyLADwmKjABHAGOYC9CWyAX7EOgA/EnjOiL0z9pADO3GySORAD+DjEyLEAwGOiAhPAOeQA9iawAX7DOgA+EnvOib48uX63niNizzmxrneifhHuQA8+i8ya5/WeZvex27d3ZmIn0BOCPKGOoh9UKZNOAnHP4A2/VN9nvkf/Pk7PrGk0q9H/YAzXLy9W07upFAAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/1_mul/target/witness.tr b/crates/nargo_cli/tests/test_data/1_mul/target/witness.tr index a539f87a554..e01c75d888c 100644 Binary files a/crates/nargo_cli/tests/test_data/1_mul/target/witness.tr and b/crates/nargo_cli/tests/test_data/1_mul/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/2_div/target/2_div.json b/crates/nargo_cli/tests/test_data/2_div/target/2_div.json new file mode 100644 index 00000000000..5122bd9b948 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/2_div/target/2_div.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1Z207DMAx1W3aDrduYEELwUCbxnvSytW/sU5jo/v8ToCLZTGkZU4+rTdTSlCZqTpxj146zJyJ6oS9xPn+uaQPWd0t9z/Q98yuLY9pX06pmoh0clpLU0xXSkwT0tHJl2h4bG5nW2r6QPuPMY3OfK/h02LNr3vF+ecepwRmxMTvfZ7oQjhPVJ7g/KJ9hohXW9mMsjBDQ4ePsmT5VkIdamzt6pFZxnK/DXEf6TYXZNk1UnGxXqU51kibvYRpFeRqn62ybrVWm4yjXuySLdgasB8TqA7Esn33GZ9lBmq5h7YfGvSOZQIT2I0fIj1Qz0Uj+uiT5Xc9LTJID0w7ZWJckMZitJMnCgAEdkuSQLitJDoFYI8InyRHJJsmBAO49/b8kOQTq1RZ/TffsAfc8AOp1TdhDxo8gSvjkjdSZ63vDnm1F6lb4hEAC0lRap8yjaIKSMtKNAO6YcM4vte8x3kaip2Ekp+VKA61rge0K8wvC1oLY+zU4FxPT+mzslAphw+bVVQgbOl4hVOF0FUK97CuEwoABHSoEn+pPtKqZaHuHjj7RPpDMRwk6kYVGTz0B7tkH2gXJX921jyvgv2fEpWTgbT2oT007Y2OnBPUlm1cX1Jd0PKhX4XRBvV72QX3KyCz6hSGD0prnXK77QKxHuozkMAXueQa0K4A//Rf+VDPRyP/TZkCsOWGTaxvXHUidub637Lm77miIOTeEonEXdN7XHcW+F3gbiV53IDnlpyZbUZXlA/vP+pfeJAAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/2_div/target/main.json b/crates/nargo_cli/tests/test_data/2_div/target/main.json deleted file mode 100644 index 0f1a7b04c8a..00000000000 --- a/crates/nargo_cli/tests/test_data/2_div/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1Y7U7CMBQ9bAMB5UNAYowm++ffdh+w/fNVJI73fwTX2Empxpjs3GUk3IRsTeD09NzbnlteALziKwb1J7DP2BkH3ji04+a7cH5v4s0+VbvQAx6WkuIYEDlGNcbQ05QuqCEceQkd2rEboaBQqdplWbVPKp3qd5WUhyJXWX7YFbrQeZF/JEWaVkVW7MtDuVelztJKH/MyPVqwIRFrRMRq9Bw5ekoUXPQLblvuj+BvNok6Yub+hshLSr+ArN+gn/qpq5lwzWRcY0zQgZmYiWKczGSCyzKTCRFrCr6ZTCFrJmPwzeQJuAgzYeb+lshLSr8+mwlRvz9rpi3PkKjfmMjrjqifWeMP4wD//GFydvnOnPcI57Xv1sRIYE3w5vF1nEPQlKWSNBPAnYNX/FLrnvNzdHY49VnTpiNnczSbIhDWlYCrm5dFjbFEB520mSjGqZNeQrbzC8Hv/O7RaxdPLE+9IK55ScwLU78A50Xb5+6PoOH3hoUXLNxVjbFGBwfBCqeTN7CTxt6c7KuQVDLbYj3jMg6UFXHNa2JeCfrp/+in2gX1f901EWtDrL+urlVMzi7fB+f9eq1qibmxgrJxt+j3tcqse8vPkei1iqlp6HBsunA/PgHqZfGSlh8AAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/2_div/target/witness.tr b/crates/nargo_cli/tests/test_data/2_div/target/witness.tr index 61aa351c57f..575c84704ad 100644 Binary files a/crates/nargo_cli/tests/test_data/2_div/target/witness.tr and b/crates/nargo_cli/tests/test_data/2_div/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/3_add/target/3_add.json b/crates/nargo_cli/tests/test_data/3_add/target/3_add.json new file mode 100644 index 00000000000..e1d1586231d --- /dev/null +++ b/crates/nargo_cli/tests/test_data/3_add/target/3_add.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1YW26DMBBcngkQ0b9+o5zA5hHMX3OUopL7H6FFNXRxjBo144pWsYQ2tvDsCw9DnojomT6H93H52hZs7hvzQM8DfZnD1/ZFW3HfkB4Qy8dhCUvq92JLh9izD59hhtpGbC1hfZzujbUdexGwvUe2z2PWYxhHtsd2j7eCk7C1aX/OYiFcTUTM/KIwc4aJDlhOhzFkxRznYyMLw2fgwDcKix/ISpzqemjLQVbyVZRdrxpRN/1JSSUb1byVqqoGVau267tWdLKuBnlpuuqiwXJyc7jN+v0wzlLHKUNgzhGwFxuv35xzAMw5AsYVA+s35nhFHgQnKYmMmce7Y7+nl4xveSYcEK8kw49ZR6fE7KpJOwe4e8I9/K7y3uN7tCCnLdd0TWGDY1bAl8i/UMWT8kwta7eo4jNd98pUxWf6XhXbcB6qeH3MqngsUkFfqjgl56pYAZTErBATwpFISlhVcgshbSDmiTQ6S7h/jpAybQ9s7fGZjsH8FULKaPmZPjayMHyiP5NSwhFSBozrQG4ON5qEMsISJ9HyP1RzvAPVuWfSjBUAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/3_add/target/main.json b/crates/nargo_cli/tests/test_data/3_add/target/main.json deleted file mode 100644 index ad8718ffc05..00000000000 --- a/crates/nargo_cli/tests/test_data/3_add/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9VX226DMAx1A/QCqHvbcz8hIUlJ3vYrQ6P//wkDLenSbNKmclxRS8gYIef4+JCYFyJ6pS/bTJcI/pTEIouLEMd3o4ng34KXy0xtgLkELpekzBbmVfGmnHJUGadwQmciyrBIjKvQ0NSKJ2mmlmdjxr4blVbvsvODs9LY4eyUU9bZj85pPTrjej/4Xnpl9Kgu1utLSHYkHmHk/N2Jsws4VQmsuQL2YuX8XWsugDVXQFxbIH9zjT82j+QZqn4k5hTvLrkvgxe/aGLLUBNl6+Q8HolxY+Zq0o4h755w4ueqe4/v0c3mtGZO86kMjNUBDw+2Seow5ajpAZPUvNCJviepmtgnKQc4fa5TxQEovBpX458iXgHWKDZPTCJuphwtPUDEDd3+DrT/EDGyAUtF3ABxtUzCQAu4IdzHViQYRdLr1D4BH4OxCigQAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/4_sub/target/4_sub.json b/crates/nargo_cli/tests/test_data/4_sub/target/4_sub.json new file mode 100644 index 00000000000..62485ea47a0 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/4_sub/target/4_sub.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81WbW7DIAzlI0nbTesZqp4AB2jg366yaOn9j7BFheqVpv3RGKlIkTHCz882OHwKIb7EZcj/TyV5AF0Vuk66Tl85VJLfSZp1gyRgWXNybhr6iSz9mD6OwRvnx1OgQD743z5YOwUXhjjGwURydqKzj/acwNR6XpQnC6G/M/bVhwLMJskW1nZQx7y3S3KuhQbbI9hJkBIwjmCztEc+wNnBWrbfAxfBlxPTgV8uzD1gchOmfBkbSOasz4U8FD51Bd8Zi/NCrsX64IvRPMvfizz7xJMaxphbxroy5I8q5u8as2aMuWXk1TGevznGu+Yh2JsUcXJGvhuY55+MWjgTFRovicJPmceqjblWkTYVcLeC7/DXinvLX6Ob5vTOOcVXU355l+MPfrsSyMILAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/4_sub/target/main.json b/crates/nargo_cli/tests/test_data/4_sub/target/main.json deleted file mode 100644 index 0cd34dd035f..00000000000 --- a/crates/nargo_cli/tests/test_data/4_sub/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9VWbQ6CMAwdgwHR6Bk8wroP2P55FYnj/kcQYmfmNP6QLtEmpCshb++9Ng17xtiB3aNaHo75lNQ8q2us47cxOOYzZrktoEqwtByMCaMKoOEilZ+clcZOgwMH1tmrcloHZ9zoJz9KD0YHmK3XM4Lx7bwgHlgWVLjNgiEyT8kNXY1o8JJYC2xoGvWfNHMr1o5Oo/zk35c8FfKEhlCzIOwrgX9Q0L+H5ppQsyDk1RLO36rxZXkk76j0U3JO+XbJucHM38xEW0ATy+7JfTyygou5VJO6Arg9oxv+Urp7+h49Ladf9rROOMa/tTxuSXEzsPYJAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/5_over/target/5_over.json b/crates/nargo_cli/tests/test_data/5_over/target/5_over.json new file mode 100644 index 00000000000..520a680c05c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/5_over/target/5_over.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1YW26DMBAcIC+Imr9+VkpuYPM0f81Rigr3P0JLasgCRlHEbtRIWQlZRngYdr3jEQcA7/gL7/fy7Xgkc9/OA3uBPN/Gpx3VstAewWTEVXDEQmwtiN2/wyeYXd5X5F5ox65GbWxIbeiaM1nnkdEjGGeyxvWMN4MTOngeCBfw5URtwL7v1AHDfccJrrsmahNzxLWpVnYOyDXSGDdReZrWRVzrRH+puKxMptKsyo02OjPZd2ySpDapKcqqLFSp06TWTVYmjQV+g0xTBjw8Y8tTB4zfvGKsy6Pyp5bFRXgk8rcUa82YvwCOpgd/L3JypnypuHaHguvAEBBMjdF7xnkUFVSpIkkkagu+zS/13Vv+Gg3E6T/ndOxopTgzHiKSjtMIYg/c7M6O1Dne42ZPmNZq7GZPuO1mXTgvNzsfvZttC/iBq5sNMW0kblfC4STq5hLlDnwiEoLXlTxCkBg55w66TydIkR335N49grTGtFZjQVrjtiC5cF6CNB+9IEUkme18D3lBok20VJAi8AnSHjLNzf07IeLjqXzC0cc0fgAXnjWW6BQAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/5_over/target/main.json b/crates/nargo_cli/tests/test_data/5_over/target/main.json deleted file mode 100644 index 51cdf4c6433..00000000000 --- a/crates/nargo_cli/tests/test_data/5_over/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81X226EIBCdBbsX3fatj036CYyIwlt/pab4/59QbTHLkn3zjNlJDBDNmcs5wPhKRO/0b4f5UWn8zNYqrdd3h/T9VxrNNuMcE4hrqLCNuLxO9IxRFTHDC7IUWxdEVGlNgiSUuNb0XReHNrLlb9OG0TvTubH37Nl599N6a6Pv/BDGMJjAnY08uWCnBPxCMoRqTJxtipM1MOcKyMte9TPbjJVQ/bZiHYH10/Rg0xN+LyJjzuM9ZfMqjeqBJo4COVHhp6zjGwkeqFIknQRwz4QTv1TeZzxHd4fTM9dU0b1Q0bECLw90B7Sav8wYNe3QAS2OPujWAS1OdeETfZMhbp84/Vm4AIVX43IUFzEw1p6ERNzMGFfaQcQN3VprlZxKi7gGirgBivgqJAz0b0tD2M1GGf+l/QIoZZmihA8AAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/5_over/target/witness.tr b/crates/nargo_cli/tests/test_data/5_over/target/witness.tr index 137f68038f6..a2d888f3003 100644 Binary files a/crates/nargo_cli/tests/test_data/5_over/target/witness.tr and b/crates/nargo_cli/tests/test_data/5_over/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/6/target/6.json b/crates/nargo_cli/tests/test_data/6/target/6.json new file mode 100644 index 00000000000..63cceafe477 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/6/target/6.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"public"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/6/target/main.json b/crates/nargo_cli/tests/test_data/6/target/main.json deleted file mode 100644 index 9e04a849f70..00000000000 --- a/crates/nargo_cli/tests/test_data/6/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"public"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/6/target/witness.tr b/crates/nargo_cli/tests/test_data/6/target/witness.tr index aa89197defa..7da9d161ef9 100644 Binary files a/crates/nargo_cli/tests/test_data/6/target/witness.tr and b/crates/nargo_cli/tests/test_data/6/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/6_array/target/6_array.json b/crates/nargo_cli/tests/test_data/6_array/target/6_array.json new file mode 100644 index 00000000000..0b22dc38811 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/6_array/target/6_array.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"y","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"t","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"t":[12],"x":[1,2,3,4,5],"y":[6,7,8,9,10],"z":[11]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/6_array/target/main.json b/crates/nargo_cli/tests/test_data/6_array/target/main.json deleted file mode 100644 index d49d0955347..00000000000 --- a/crates/nargo_cli/tests/test_data/6_array/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"y","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"t","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"t":[12],"x":[1,2,3,4,5],"y":[6,7,8,9,10],"z":[11]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/6_array/target/witness.tr b/crates/nargo_cli/tests/test_data/6_array/target/witness.tr index a304ad49edb..8a348c2fcda 100644 Binary files a/crates/nargo_cli/tests/test_data/6_array/target/witness.tr and b/crates/nargo_cli/tests/test_data/6_array/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/7/target/7.json b/crates/nargo_cli/tests/test_data/7/target/7.json new file mode 100644 index 00000000000..4eae480d06c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/7/target/7.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2d+ZPNRxTFj2UYO7Hv+769N4t5Y1+DEARBEMswCIIgCIIgCIIgCIIgCIIgCIKQqvxb6VvTU24681ufrvp21fdV3Xp9VTlz7rlvPs3UzJu/AfyDikc1U9Xtc77qqzt9Daev6fR5ts+zunmOfg37d/LUn9VyNGo7fb7T13H6uk5fz+nrO30Dp2/o9I2cvrHTN3H6d5y+qdM3c/rmTt/C6Vs6fSunb+30bZy+rdO3c/r2Tt/B6Ts6fSen7+z0XZy+q9N3c/ruePsaqWb15SGvg8rd17F7rWf318DuqZHdRxObe1Obb3ObY0ubV2ubS1s7f3s7Z0f78Tpb312tv+7WS+VrE3j7uVD5Gqx87ddU/vOV/x6meprqZaq3qT6m+prqZ6q/qQGmBprKmMqaKjBVaKrIVLGpQaZKTOVMlZoabGqIqaGmhpkabmqEqZGmRpkabWqMqbGmxuG/jxr2eaR9LswMKioqLykozxZmF2cKSstyxZmi4rJBuWwuW5wrXlqQKywszxXlSkrLSksypdmiwvLssuLSwmWZikctpZXxe2R7EH29y/OVqWF37j6qOVlm/B5Zpmftd7w617TP1at4TdQKMBOcj+Pm2LCKP6N+8BBLGh9AdwJ4L/5Qc0/g7ygD5wUCYg61ifP3JPqaiPjgxPSs/b6nzimcPDUn2kDZupOQbDjJ3JP4OwoKp3zi/L2IviYjPjgxPWu/76tzCidPzck2ULbuFCQbTjL3FP6OgniVf+FNqkLXN9epiAPKdYhZ9ib6mob4oMz0rP1+oM4plD01p9lA2brTkWwoy9zT+TsK4lUuj6ngQ3kG4oByXWKWfYi+ZiI+KDM9a78fqnMKZU/NmTZQtu4sJBvKMvcs/o6CeJXLYwb4UJ6NOKBcj5hlX6KvOYgPykzP2u9H6pxC2VNzjg2UrTsXyYayzD2Xv6MgXuXymA0+lOchDijXJ2bZj+hrPuKDMtOz9vuxOqdQ9tScbwNl6y5AsqEscy/g7yiIV7k85oEP5YWIA8oNiFn2J/pahPigzPSs/S5W5xTKnpqLbKBs3TIkG8oydxl/R0G8yuWxEHwoL0EcUG5IzHIA0ddSxAdlpmftt1ydUyh7ai61gbJ1lyHZUJa5l/F3FMSrXB5LwIfycsQB5UbELAcSfa1AfFBmetZ+P1HnFMqemitsoGzdlUg2lGXulfwdBfEql8dy8KG8CnFAuTExywzR12rEB2WmZ+33U3VOoeypudoGytZdg2RDWeZew99REK9yeawCH8prEQeUmxCzzBJ9rUN8UGZ61n4/U+cUyp6a62ygbN31SDaUZe71/B0F8SqXx1rwobwBcUD5HWKWBURfGxEflJmetd/P1TmFsqfmRhsoW3cTkg1lmXsTf0dBvMrlsQF8KG9GHFBuSsyykOhrC+KDMtOz9vuFOqdQ9tTcYgNl625FsqEsc2/l7yiIV7k8NoMP5W2IA8rNiFkWEX1tR3xQZnrWfr9U5xTKnprbbaBs3R1INpRl7h38HQXxKpfHNvChvBNxQLk5Mctioq9diA/KTM/a71fqnELZU3OXDZStuxvJhrLMvZu/oyBe5fLYCT6U9yAOKLcgZjmI6Gsv4oMy07P2+7U6p1D21NxrA2Xr7kOyoSxz7+PvKIhXuTz2gA/l/YgDyi2JWZYQfR1AfFBmetZ+v1HnFMqemgdsoGzdg0g2lGXug/wdBfEql8d+8KF8CHFAuRUxyxzR12HEB2WmZ+33W3VOoeypedgGytY9gmRDWeY+wt9REK9yeRwCH8pHEQeUWxOzLCX6Oob4oMz0rP1+p84plD01j9lA2brHkWwoy9zH+TsK4lUuj6PgQ/kE4oByG2KWg4m+TiI+KDM9a7/fq3MKZU/NkzZQtu4pJBvKMvcp/o6CeJXL4wT4UD6NOKDclpjlEKKvM4gPykzP2u8P6pxC2VPzjA2UrXsWyYayzH2Wv6MgXuXyOA0+lM8hDii3I2Y5lOjrPOKDMtOz9vujOqdQ9tQ8bwNl615AsqEsc1/g7yiIV7k8zoEP5YuIA8rtiVkOI/q6hPigzPSs/f6kzimUPTUv2UDZupeRbCjL3Jf5OwriVS6Pi+BD+QrigHIHYpbDib6uIj4oMz1rvz+rcwplT82rNlC27jUkG8oy9zX+joJ4lcvjCvhQvo44oNyRmOUIoq8biA/KTM/a7y/qnELZU/OGDZStexPJhrLMfZO/oyBe5fK4Dj6UbyEOKHciZjmS6Os24oMy07P2+6s6p1D21LxtA2Xr3kGyoSxz3+HvKIhXuTxugQ/lu4gDyp2JWY4i+rqH+KDM9Kz9/qbOKZQ9Ne/ZQNm695FsKMvc9/k7CuJVLo+74EP5AeKAchdilqOJvh4iPigzPWu/v6tzCmVPzYc2ULbuIyQbyjL3I/6OgniVy+MB+FB+jDig3JWY5RiiryeID8pMz9rvH+qcQtlT84kNlK37FMmGssz9lL+jIF7l8ngMPpSfIQ4odyNmOZbo6znigzLTs/b7pzqnUPbUfG4DZeu+QLKhLHO/4O8oiFe5PJ6BD+WXiAPK3YlZjiP6eoX4oMz0rP3+pc4plD01X9lA2bqvkWwoy9yv+TsK4lUuj5fgQ/lNwueW/bypYkcMyFf6FXDIJ7KAJA8V0KhtKt9UHVN1TdUzVd9UA1R8gjcy1dhUE1Py+wPl11XJb0eRN+OX936WtxqVd7aTN1KS9+2QHxOXn0qUH4KR77mWb/HrZKqzKfl6uXx5Rv430B3/f/wL/hUzPti1AAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/7/target/main.json b/crates/nargo_cli/tests/test_data/7/target/main.json deleted file mode 100644 index aca74d546fd..00000000000 --- a/crates/nargo_cli/tests/test_data/7/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/7/target/witness.tr b/crates/nargo_cli/tests/test_data/7/target/witness.tr index 2abb65d513e..09b25ee04e9 100644 Binary files a/crates/nargo_cli/tests/test_data/7/target/witness.tr and b/crates/nargo_cli/tests/test_data/7/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/7_function/target/7_function.json b/crates/nargo_cli/tests/test_data/7_function/target/7_function.json new file mode 100644 index 00000000000..03a585b2321 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/7_function/target/7_function.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"a","type":{"kind":"field"},"visibility":"private"},{"name":"arr1","type":{"kind":"array","length":9,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"arr2","type":{"kind":"array","length":9,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"param_witnesses":{"a":[3],"arr1":[4,5,6,7,8,9,10,11,12],"arr2":[13,14,15,16,17,18,19,20,21],"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/7_function/target/main.json b/crates/nargo_cli/tests/test_data/7_function/target/main.json deleted file mode 100644 index 66db45e2d85..00000000000 --- a/crates/nargo_cli/tests/test_data/7_function/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"a","type":{"kind":"field"},"visibility":"private"},{"name":"arr1","type":{"kind":"array","length":9,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"arr2","type":{"kind":"array","length":9,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"param_witnesses":{"a":[3],"arr1":[4,5,6,7,8,9,10,11,12],"arr2":[13,14,15,16,17,18,19,20,21],"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/7_function/target/witness.tr b/crates/nargo_cli/tests/test_data/7_function/target/witness.tr index 809861d3d97..65f2746c7b1 100644 Binary files a/crates/nargo_cli/tests/test_data/7_function/target/witness.tr and b/crates/nargo_cli/tests/test_data/7_function/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/8_integration/target/8_integration.json b/crates/nargo_cli/tests/test_data/8_integration/target/8_integration.json new file mode 100644 index 00000000000..55aaf9efbdc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/8_integration/target/8_integration.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":100,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":100,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"d","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"m","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"b":[101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200],"c":[201,202,203,204],"d":[205,206,207,208],"m":[209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/8_integration/target/main.json b/crates/nargo_cli/tests/test_data/8_integration/target/main.json deleted file mode 100644 index 900b8e934f7..00000000000 --- a/crates/nargo_cli/tests/test_data/8_integration/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":100,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":100,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"d","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"m","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"b":[101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200],"c":[201,202,203,204],"d":[205,206,207,208],"m":[209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/8_integration/target/witness.tr b/crates/nargo_cli/tests/test_data/8_integration/target/witness.tr index 09bef840365..b5cb2bd535d 100644 Binary files a/crates/nargo_cli/tests/test_data/8_integration/target/witness.tr and b/crates/nargo_cli/tests/test_data/8_integration/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/9_conditional/target/9_conditional.json b/crates/nargo_cli/tests/test_data/9_conditional/target/9_conditional.json new file mode 100644 index 00000000000..8f480745336 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/9_conditional/target/9_conditional.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"public"}],"param_witnesses":{"a":[1],"c":[2,3,4,5],"result":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42],"x":[6,7,8,9,10]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/9_conditional/target/main.json b/crates/nargo_cli/tests/test_data/9_conditional/target/main.json deleted file mode 100644 index 870dd6ef11c..00000000000 --- a/crates/nargo_cli/tests/test_data/9_conditional/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"public"}],"param_witnesses":{"a":[1],"c":[2,3,4,5],"result":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42],"x":[6,7,8,9,10]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/9_conditional/target/witness.tr b/crates/nargo_cli/tests/test_data/9_conditional/target/witness.tr index ea4c9d0bf37..05508515ddb 100644 Binary files a/crates/nargo_cli/tests/test_data/9_conditional/target/witness.tr and b/crates/nargo_cli/tests/test_data/9_conditional/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/arithmetic_binary_operations/target/main.json b/crates/nargo_cli/tests/test_data/arithmetic_binary_operations/target/arithmetic_binary_operations.json similarity index 100% rename from crates/nargo_cli/tests/test_data/arithmetic_binary_operations/target/main.json rename to crates/nargo_cli/tests/test_data/arithmetic_binary_operations/target/arithmetic_binary_operations.json diff --git a/crates/nargo_cli/tests/test_data/array_dynamic/target/array_dynamic.json b/crates/nargo_cli/tests/test_data/array_dynamic/target/array_dynamic.json new file mode 100644 index 00000000000..687a56bcafd --- /dev/null +++ b/crates/nargo_cli/tests/test_data/array_dynamic/target/array_dynamic.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"t","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"index","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"},{"name":"index2","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"},{"name":"offset","type":{"kind":"field"},"visibility":"private"},{"name":"sublen","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"index":[8,9,10,11,12],"index2":[13,14,15,16,17],"offset":[18],"sublen":[19],"t":[7],"x":[1,2,3,4,5],"z":[6]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_dynamic/target/main.json b/crates/nargo_cli/tests/test_data/array_dynamic/target/main.json deleted file mode 100644 index e632943a2ee..00000000000 --- a/crates/nargo_cli/tests/test_data/array_dynamic/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"t","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"index","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"},{"name":"index2","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"},{"name":"offset","type":{"kind":"field"},"visibility":"private"},{"name":"sublen","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"index":[8,9,10,11,12],"index2":[13,14,15,16,17],"offset":[18],"sublen":[19],"t":[7],"x":[1,2,3,4,5],"z":[6]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_dynamic/target/witness.tr b/crates/nargo_cli/tests/test_data/array_dynamic/target/witness.tr index 44f38a81561..756e5de1740 100644 Binary files a/crates/nargo_cli/tests/test_data/array_dynamic/target/witness.tr and b/crates/nargo_cli/tests/test_data/array_dynamic/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/array_len/Prover.toml b/crates/nargo_cli/tests/test_data/array_len/Prover.toml index 3c3295e6848..a5ffe607b73 100644 --- a/crates/nargo_cli/tests/test_data/array_len/Prover.toml +++ b/crates/nargo_cli/tests/test_data/array_len/Prover.toml @@ -1,2 +1,3 @@ len3 = [1, 2, 3] len4 = [1, 2, 3, 4] +x = 123 diff --git a/crates/nargo_cli/tests/test_data/array_len/src/main.nr b/crates/nargo_cli/tests/test_data/array_len/src/main.nr index 9099cfa2144..65c2295cefb 100644 --- a/crates/nargo_cli/tests/test_data/array_len/src/main.nr +++ b/crates/nargo_cli/tests/test_data/array_len/src/main.nr @@ -1,18 +1,18 @@ use dep::std; -fn len_plus_1(array: [T]) -> Field { +fn len_plus_1(array: [T; N]) -> Field { array.len() + 1 } -fn add_lens(a: [T], b: [Field]) -> Field { +fn add_lens(a: [T; N], b: [Field; M]) -> Field { a.len() + b.len() } -fn nested_call(b: [Field]) -> Field { +fn nested_call(b: [Field; N]) -> Field { len_plus_1(b) } -fn main(len3: [u8; 3], len4: [Field; 4]) { +fn main(x: Field, len3: [u8; 3], len4: [Field; 4]) { assert(len_plus_1(len3) == 4); assert(len_plus_1(len4) == 5); assert(add_lens(len3, len4) == 7); @@ -20,4 +20,9 @@ fn main(len3: [u8; 3], len4: [Field; 4]) { // std::array::len returns a comptime value assert(len4[len3.len()] == 4); + + // Regression for #1023, ensure .len still works after calling to_le_bytes on a witness. + // This was needed because normally .len is evaluated before acir-gen where to_le_bytes + // on a witness is only evaluated during/after acir-gen. + assert(x.to_le_bytes(8).len() != 0); } diff --git a/crates/nargo_cli/tests/test_data/array_len/target/array_len.json b/crates/nargo_cli/tests/test_data/array_len/target/array_len.json new file mode 100644 index 00000000000..b3214c96d5e --- /dev/null +++ b/crates/nargo_cli/tests/test_data/array_len/target/array_len.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"len3","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"len4","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"len3":[2,3,4],"len4":[5,6,7,8],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1YWU7DMBB1mlK6ZytRKSA+uIAnS+P8cRWiJvc/Ak47Qe4AXx5XQWKkkf2yvMy88SLnTQjxKi7maZ+gzw3sEzxFfIfv+dgOz07xnod9gXim/R7fNW2C7Tu20s5gbnDl8lgUbZW1kMOHzOpGlbIom6MCBaUqT5nK81YVqqqbupI1FHkLXVnnHZItGLja7mwnHzWh5jHnv+Djkma8S6M/JbUzx8HMQU6CfIfquP3hGuvHXRRp6YB3JfgGv6u8V/w1kgblqDUdFlhXsXqMmg4L9Vr7RlwmWaA91B5pj7UnmMSwOfTPmpvFhuAtwQHBIcERwTHBifi+ofgONbWt/5qRay/czB+qn93GJ2HDxNXXYsuo3+Po9TtTQ2DPlWHOEDLqdxizfsVXnBDZcUkjZ4gZ9Xsaq37ZVZyQ8MUJe0b9nm+kn7QzYFxn4MCo38sf0Y9xngDjmAFX+nm285fUeccWZyZvdYjli/n6EPtg9P8PsZacOxSUmzcV4z7E9nmn/DVyugikjHHOjRjpX7/f/vL19gk4DfzMbhQAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_len/target/main.json b/crates/nargo_cli/tests/test_data/array_len/target/main.json deleted file mode 100644 index cfa010d9788..00000000000 --- a/crates/nargo_cli/tests/test_data/array_len/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"len3","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"len4","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"len3":[1,2,3],"len4":[4,5,6,7]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81U2w7CIAxlY+5m4re0A7by5q+4DP7/E9y0JpUYX4TEk5BSSE+v6VkpNaonqv3ULHuh14muWT+xnU7sNf8desN/Db+1++nUO2qWV5bwG7ATXAZma8MyBTR4g8mv5MC6dSYkdOS2iYwJZGnxq1/AozUBo/MmMlmfgSvEBzbNNUlRZc6/z8cFMt5B3Jukd3IO2gI5qcRPWsfLh7eszks0aSjAO6p8w18q7zF/j0BQ/nVNOxHja1l+W44H7lYCBc+lBQAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_len/target/witness.tr b/crates/nargo_cli/tests/test_data/array_len/target/witness.tr index c98090370a3..07d1eaaf7bd 100644 Binary files a/crates/nargo_cli/tests/test_data/array_len/target/witness.tr and b/crates/nargo_cli/tests/test_data/array_len/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/array_neq/target/array_neq.json b/crates/nargo_cli/tests/test_data/array_neq/target/array_neq.json new file mode 100644 index 00000000000..c21e92e6d68 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/array_neq/target/array_neq.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"b":[33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_neq/target/main.json b/crates/nargo_cli/tests/test_data/array_neq/target/main.json deleted file mode 100644 index 67c2223df62..00000000000 --- a/crates/nargo_cli/tests/test_data/array_neq/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"b":[33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_neq/target/witness.tr b/crates/nargo_cli/tests/test_data/array_neq/target/witness.tr index 591e397db8d..1c0e24dd401 100644 Binary files a/crates/nargo_cli/tests/test_data/array_neq/target/witness.tr and b/crates/nargo_cli/tests/test_data/array_neq/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/array_sort/target/array_sort.json b/crates/nargo_cli/tests/test_data/array_sort/target/array_sort.json new file mode 100644 index 00000000000..a65e13fd020 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/array_sort/target/array_sort.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"xs","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"xs":[1,2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1bzW7bMAym7SRt0tT9yZoV7XZZd+h26MTYbuzbXqVB7fd/hFaNDNBOgR700bCAEAhkORFNfSQ/SkpSEBHTXqL3V+zaU9GPe/3E9aduXNIbn4hWviel7f93rfETjnC6jLatcUC2JmBb23g4cTE0p69jIzPPeV5vNzVn/GI21a4sTF7snksuuSiL102ZZXWZl9tqV21NxXlWc1NUWSOee6Kg9w6IjVacacz7HjzvVhKwncA86+SBr10/BsLP+AkD45vvgfj9DCT+FkD8gDHDaPzQvGVrwoLwvPWLwogb4Fqms9bwteuBwuAtoJ/5AYjf70Di7wygq272AuQaRuOH5i27nj0jPG89Uhh5h+StOyB+fwLBD7iu5kcgfn8pDN6aAPEDxgwPhZ/xE+haAZm/T4Hgh1x3PAHx+0dh5O+URslZPBR+xk+gZxQzoC7kvkueKUuJwbGIrCVTlC7uxg8h40dTt6strSxdey7uzYUf28/OXCvPja1fFmJcJNpI6FjQ4XcPUe/6Mz1zca8dnwpbCIfJR46B9yAmpcPzdOgC34K7FGDavnXkae+ZY17cIQvNhmjUxXW/ETe8BM75HOgLGH49AkNv7pH4DVXEYIXnff4zCqDQDFjEUtdeiHvHIobROUgRS6lbxKwjtYuYVkL62pVTGEUsBc75AugLGH7KRQyJn7QzBts5Adp5SdjCfUBMCn66xOnq/ELoSlxPer6z0uarAqkz9Z7Tx1GV9LWcdKWg95qwSaox72u8j1SJD41pK2jiQ+5MV4QqvE0zFPGtSIf4vonrI/F56lw5QNF6b2jcxGfnfYP3kSrxoTFtBU18yN3MmmDEVw9FfGvSIb7v4vpIfJ461w5QtN5bGjfx2Xnf4n2kSnxITD/7g0tf3gB2Lz+NSTMAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/array_sort/target/main.json b/crates/nargo_cli/tests/test_data/array_sort/target/main.json deleted file mode 100644 index 22dc7dc63eb..00000000000 --- a/crates/nargo_cli/tests/test_data/array_sort/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"xs","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"xs":[1,2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2az27bMAyHWTtJuzZN/2TNina7rDt0O3RSbDf2ba+yYPb7P8JixAJkr8AO+mhYQAkEthCEIn+kPktGChGxcrSTwyfprmfeOBmM0248736XDn6felf/O9/c+Fd3NWFmTzhfRjvWJKJYUzhW1w+nXQ99kP/3RmZe87zebWub2d9mW+3LwuTF/rW0pS3K4s+2zLK6zMtdta92prJ5VtumqLLGm/dUwe8DqI1Wn2nk/Qjn7SyF4wTXWW8dhMb1eST9TJhZsL/tI6jfl0j67xzUD+wZS+tHc6t9JpwLz62vEkffgHuZ3l4jNK4niYNbYJ3tE6jft0j67wLwVTdHA1ljaf1obrX72QvhufUscaw7klsPoH7fI9EP3FfbZ1C/HxIHt2agfmDP2LH0M2GG7hXI9fsSiX7kvuMF1O+nxLF+5zJJZtmx9DNhhr6jWIC+yHOXez/tLIF7kHyGzClftt83AvpdHnxcyr/vYNFNYVukZTeJG7eTng3mnPKGgITTVqYN5OPhzdglmPMlWAtMv8HCog+EpH7a4MNgdch7IdMH3+rg40pGAN9K+uBrJ9UGn1YxQ+PKJQ7wrcCcr8BaYPopg4/Uz48zgeOcgXFeg75SeQNMCnW65nz1/olw493PBrVrza3XhUJOMphnqONKFKGvVaQbBb+3wi5Sjbxv+Rqpgo/W1BkNPvI0sxbqwds0Y4FvLTrg++jdv4Mv0Oe6E5T2eyfTBl+b9x1fI1Xw0Zo6o8FHnmY2goGvHgt8G9EB3yfv/h18gT43naC033uZNvjavO/5GqmCj9T0rT/SD+0vNTZgELEvAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/assert/target/main.json b/crates/nargo_cli/tests/test_data/assert/target/assert.json similarity index 100% rename from crates/nargo_cli/tests/test_data/assert/target/main.json rename to crates/nargo_cli/tests/test_data/assert/target/assert.json diff --git a/crates/nargo_cli/tests/test_data/assert_statement/target/main.json b/crates/nargo_cli/tests/test_data/assert_statement/target/assert_statement.json similarity index 100% rename from crates/nargo_cli/tests/test_data/assert_statement/target/main.json rename to crates/nargo_cli/tests/test_data/assert_statement/target/assert_statement.json diff --git a/crates/nargo_cli/tests/test_data/assign_ex/target/main.json b/crates/nargo_cli/tests/test_data/assign_ex/target/assign_ex.json similarity index 100% rename from crates/nargo_cli/tests/test_data/assign_ex/target/main.json rename to crates/nargo_cli/tests/test_data/assign_ex/target/assign_ex.json diff --git a/crates/nargo_cli/tests/test_data/bit_and/target/bit_and.json b/crates/nargo_cli/tests/test_data/bit_and/target/bit_and.json new file mode 100644 index 00000000000..6730eae1cbe --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_and/target/bit_and.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2YW27DIBBFx3bzfr+aLqALgNhO8F+30qj2/qVK/W1DC+3ESZoPX5A/QIpAlnO5zJgjmCcieqaflphfvUWmfzG9aNZkhNMSV+xitKVD7ZN6zDRtzB/Ys4HpY/PTrcvywf/zSZe5itg4Nu8k/7wT3dAZXPE5ZV4IFxPRJfi3JqZME234+0OOTWA+zESxSUq/NmfiYG6rlYp9lpWHXSlT+Sp2xVHlIsuPeyWVzFX+tlNpWqpMHYpjcRCFzNJSVnmRlpVuQiYArcoYe8CtUfgCUkwBSBxIHdPzTR6AhNH0AiSdQA4kvRDXQOKbqCmQOoQDUhe3RmETZwFv49q7E9sWQVX2gL76hIX9xcYgPOyRnrlfDiZ7krt2ynMAFUm1eepxdAodV0kaONAdEu7jd7XuIT5HZyeHNsfUFwSQV1Dud8TGAQINNSMTULTumNoNAa03xufoDAIx2DPi9GdjOiHUSbKSvoAyITdAmbJxAEpDzUnNNEp3Ru0Gil73DJ8jJ17HN7wiThahuG2a8ldLmpt+wZ6FWhJG00stSSfwnf5qSTqRo9qcrS1uKyHnhIPIArfGUNzmzSOQlqZfsWcBSBhNL0DSCeRA0ol0DSRYcfsEpCXhgLTCrfH32mEBb+O6vhPbFkFVroG+NoSFvY9rKNIz9/vIxuEa2lBzYwKK1t1Su6+het1bfI6cFreRMY2ZR755bPsC74CZ84wlAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_and/target/main.json b/crates/nargo_cli/tests/test_data/bit_and/target/main.json deleted file mode 100644 index ff2a2efd56c..00000000000 --- a/crates/nargo_cli/tests/test_data/bit_and/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1Yy2rDMBDc2Inzfj+afkDvUmwn8q2/0lD7/6HQcyUqNYoI5OCRENQLRjrN7s6O1su+EtEb/Voivx7dzNzf9cnaGe/hsBg5BsHljKUSo+/wACdBEa0cfWtHiXY6cnymHguQs3NR1JdTzXP+wU7VVZSsKK9nwQUvRfl5Enlei0Jcqmt1YRUv8po3ZZXXjTLGUwBWowPr43JkvkWcUPwiHkiMjAKIeOCIOAsg4gQo4gFQxBkuR2YKZ5qC4XX4hNuIHiIfAuMaAblN6cHDIHyjQMZsxzu27n19Jg80kXnIiRw/Lo8L8th0fBVp7AF3Qjjx+8p7gq/R3R8tZk5DNQHkyGvHO7XuXRNoidnThKJxZxR3E1B4M3yN7ppAAo4ZMf0ZTueEmiQbHqqhzMlPQ1lY966htMScO0GjcJcUd0NReS/xNfoT6kzHvNTniu4Nnc8KyPe/X64JxtYSY0MB9hLK0Rfd9hLK6dTxGe1yTTC+Bgpvg8uxW65JEW8lxo4CiHjriHgXQMSw5ZoU8RYo4h3h/yamKRhe90+4jegh8j0wrgOQ21BjMDJmO94X696NwS0xD5pQNO6R4h6DVd5HfI28LteQnCZWjPbjMfYDkGSEtnQeAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_and/target/witness.tr b/crates/nargo_cli/tests/test_data/bit_and/target/witness.tr index 577b19650f8..545657e08fe 100644 Binary files a/crates/nargo_cli/tests/test_data/bit_and/target/witness.tr and b/crates/nargo_cli/tests/test_data/bit_and/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/bit_shifts_comptime.json b/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/bit_shifts_comptime.json new file mode 100644 index 00000000000..ee69d405a9c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/bit_shifts_comptime.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1W7W6DIBS9oLW6Lv2zFwHBin8WuzeZKb7/I0w32K7Yblm9NDbpTQhE8dyPw5XzDAAv8GVsGNzN7TASN0Jjbm7dLJZZyeiwxJlwr8WWEbFnvjjC9Gtc+wK98+8zxIffmw7jDeZcMbTmbk/yyx52AadAz/z3exQL0NVEZEB+1sQeYVIHLH0DcVRM7grVBj4TWt+TJlLioLWtSyuVfBdl05lK6Ko7GGlkZapTaZSyRpu66ZpaNEIrK/uqUb3Lg1+PJQMskUCc5ubE3CWEOacEWLYfzXzGNTuwQN4YMqXDEjjeDVqnAXej+T6I0OwSAj9hHaP+DGKRtImAmwHd4Y+Vd4wbBkGuuqY3UmJypUosNB0Re6LEtm7O0bP/KLEjzLkKldgR/lZi53AeSuyyfSuxkcBX+FFiOUxvH1w8St8ea9nt35+2QPcTyeE+lBhlzgUdFzdTYgXEUWJPaP1QYgsxC1dQatwdrFuJjXnv6DmKqsQoa8qCGLF9AFmXhFRMEwAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/main.json b/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/main.json deleted file mode 100644 index 31861cc70c0..00000000000 --- a/crates/nargo_cli/tests/test_data/bit_shifts_comptime/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1VUW6DMAw1hFJYp/3sIjFJSvIz7SpDDfc/whqVqKnVr2JXVOqTEIFIz/Gz4/cJAN9wQXV+6uX9W6yh2IdlL0Gvw1DxcWkgeJAX6Y+kgSI6cIqAWfQsdv5WRYwMJVgAo4/WxnGIaPBPD2HyTls3HT16dN6dBm9M9NaPYQqjDtqaiLMLZl7yqB/nQsKlFcg0Rs1cO8WYc8PAFecEj3cbFtgvMDZ8XLo8765YN6R2CfketAI5AYlDdfwCwWEgVaSdAG8LfM0vlXfLX6ObgbJlTYXdGzfo3hR2f+bo4AnunQL9wNW9O7idWAlKIPbaZrk4xnzaMzZeB6/h3pw593y1eJp79yDj3h/F+u3eKzn7RVBu3gNs271T3gf+Gom6N6emFTljiX/W0KRotA8AAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Nargo.toml b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Nargo.toml new file mode 100644 index 00000000000..661f4f937d5 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "bit_shifts_runtime" +authors = [""] +compiler_version = "0.1" + +[dependencies] diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Prover.toml b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Prover.toml new file mode 100644 index 00000000000..98d8630792e --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/Prover.toml @@ -0,0 +1,2 @@ +x = 64 +y = 1 \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_runtime/src/main.nr b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/src/main.nr new file mode 100644 index 00000000000..271a1ecb880 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/src/main.nr @@ -0,0 +1,9 @@ +fn main(x: u64, y: u64) { + // runtime shifts on comptime values + assert(64 << y == 128); + assert(64 >> y == 32); + + // runtime shifts on runtime values + assert(x << y == 128); + assert(x >> y == 32); +} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/bit_shifts_runtime.json b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/bit_shifts_runtime.json new file mode 100644 index 00000000000..be2c752ef28 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/bit_shifts_runtime.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"unsigned","width":64},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/witness.tr b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/witness.tr new file mode 100644 index 00000000000..dcb5e52682c Binary files /dev/null and b/crates/nargo_cli/tests/test_data/bit_shifts_runtime/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/blackbox_func_simple_call/target/main.json b/crates/nargo_cli/tests/test_data/blackbox_func_simple_call/target/blackbox_func_simple_call.json similarity index 100% rename from crates/nargo_cli/tests/test_data/blackbox_func_simple_call/target/main.json rename to crates/nargo_cli/tests/test_data/blackbox_func_simple_call/target/blackbox_func_simple_call.json diff --git a/crates/nargo_cli/tests/test_data/bool_not/target/main.json b/crates/nargo_cli/tests/test_data/bool_not/target/bool_not.json similarity index 100% rename from crates/nargo_cli/tests/test_data/bool_not/target/main.json rename to crates/nargo_cli/tests/test_data/bool_not/target/bool_not.json diff --git a/crates/nargo_cli/tests/test_data/bool_or/target/main.json b/crates/nargo_cli/tests/test_data/bool_or/target/bool_or.json similarity index 100% rename from crates/nargo_cli/tests/test_data/bool_or/target/main.json rename to crates/nargo_cli/tests/test_data/bool_or/target/bool_or.json diff --git a/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/brillig_acir_as_brillig.json b/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/brillig_acir_as_brillig.json new file mode 100644 index 00000000000..f24783e363c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/brillig_acir_as_brillig.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2bzY7bIBDHx+DPJLuHPkHUQ6XeTJxsnJsfpJdGm1RqL32LnvrOXXeZ9h+Mt6sY1jQCKYIEmPmB7RmY4BURvaPnlDx9hM7XTx+py2bi3zqd19OSStzJqpFXQHmv88r4vU85lDtHHLn7eaozYK0s47zX9amH6yNB3xp0psCT6TK3XVoYc/o7hs4hH1muIYEuZJEBsaQBsWQBsSQzs1Q0tH0V1GfwmzD69nUK6gtdFhY5haUdjr30MHbU08F31rUAhiIAliwgljQgFhkQizBYKqjHZ0oYfQsKy2e99hkvyLI26hzBo0zhWLYAWU39sN2e9puTatTnenM4trt6uzs+tKpVu3b3uGmb5tRu2/3heNjXB7VtTuq8OzRnLUw6kHU6P6e3WmxKd7IuFpuppYwLTVx0uB4TGXrMebwnzzerj4uUepCbkbub39e4M/fXqAaRQc+ppEur7YvZ4Y5TWXCnylZc8CD7jw40TuZqtE+8wxQ09H7oXfvn9D0Nr1UCZaHbyBfaJCNycKfL/XmnS27nxMuu3avx5ZBNDpPZf+8v5NrQKT3oZllXPvgb/eCrnNwZkYLcGmQzXEQUtEHyauwLT5x9+q7zioaG4lbCdr0xGAuL+dgCkWWOCHSNhcXmZklmZhkL/5gr+7EtpG2ryfUZ5N+gPrfILiyyMUxncv0rnOQjlDYWHmBdY+GkuVhkQCxm2CShy/DDmob3l4Q2H3R+p/uWRl/zfpXQ5iP0HbNJlYd5wdRBmXWN2aS5WdKAWLKAWPKAWIqAWMqAWJKZWcb8KddjqHWhy+g7hUUe24YFyEB/yuPHvitdlhZ9SwvXytIX55L7dDqvp6Xfc4l6Ovi+hPEmBt+cLGVALEVALHlALFlALGlALDIgFmGwJFDP6zm2Vbie4zZfdM5rwTujbwV9OOc2X6FvQZd7CtveA23qa/Y6Xv8u+9/PKZVQ/mmZWE7xnNKLKZ5T8sgSzynFc0pmu3hOKZ5TiueUpnNHn+WHJfqs2/RZn6A++qxpLNFnRZ91DXf0WX5Yos+6TZ/1A+qjz5rGEn1W9FnXcMf3QSyyS5A19eRl5UCWfh/k8a2C+pU7WRdB/QWU4/sgE2Xy3/Su5S7J3c3va9xL99fI6xFhl3OaGIyYfgFXBJCIukAAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/main.json b/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/main.json deleted file mode 100644 index 8200f09e496..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_acir_as_brillig/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2bwY7bIBCGx2AbO8nuoU+QU6Xe7DjZODc/SC+N1qnUXvoWPfWdu+6C+pvF7SqG9WwEUgQ2MPOBMQMTvCGiD/Qckqef0PH26Sd12g7mXqfjal6oE3+yKuQVkD7quLTuDyGHdOeJI/ffT1UGrKWjnfc6Pw3wfCTo24LOFHgynTZl1w7GnP62ofPIR45nSKALWSQjlpQRS8aIJVmYpaSXc18J+RncE1bdIa+GfKXTwiFHOcph24sAbUc9HVwbXStgUAxYMkYsKSMWyYhFWCwl5OM7Jay6injZrNe+44oca6POEzzKFJ5lC5DVVA/7fX/c9XVTf6l2p3N7qPaH80Nbt/WhPTzu2qbp2317PJ1Px+pU75u+vhxOzUULkx5k9Zfn8FaLTelP1mixmTrSuNDERYfvNpGlx+7Hewo8WEM8pDSA3Iz8Df5Q7c78P6MKRLLuU0Hjgcp4pzl66Tww1iYxTBBBrYvZ5puZyFwPSreWThnwAVw5WHZ6sNS5x4GnyO9LbLsYiHi7TUJyqkCcQ/ih4xLGagL3bsHVM1jvKVdKiGUzOfqIQNeUK2VplmRhlimXgb0anNp2uLYnJj+D+Dvk5w7ZyiEbXTs21/9cECHcL1NbSqNrygWxFItkxGJvtRMab1m39HJ8SSjzUcd3um5h1bXHq4Qyn6Du1JxUBugXDB2kja6pOWlplpQRS8aIJWfEohixFIxYkoVZpuypyUf33Eqn0XYKhzwzN6xABtpT036su9Fp6dC3dnBtHHWxL02dTsfVvPCnL1FPB9draG9i8S3JUjBiUYxYckYsGSOWlBGLZMQiLJYE8s16zsxVuJ4zZb7q2KwF76y6JdQxsSnzDeoqGu8pXHsPnFNfs9cJ6gR772dbCkj/cnSsCfFsyz9DPNsSkCWebYlnW+xy8WxLPNsSz7bM5442KwxLtFm3abM+Q360WfNYos2KNusa7mizwrBEm3WbNusn5EebNY8l2qxos67hjt8QOGQXIGvuycvSgyz9DcHjWzn1S3+yRk79FaTjNwQzZZq/6X3LXZO/wR+q3Wv/zyjoEWGffZpYjBh+A+k+QZzuPgAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_arrays/target/main.json b/crates/nargo_cli/tests/test_data/brillig_arrays/target/brillig_arrays.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_arrays/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_arrays/target/brillig_arrays.json diff --git a/crates/nargo_cli/tests/test_data/brillig_assert/target/brillig_assert.json b/crates/nargo_cli/tests/test_data/brillig_assert/target/brillig_assert.json new file mode 100644 index 00000000000..406f4d84d48 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_assert/target/brillig_assert.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9VWUW7DIAw1kDbNtPUsEKCBv11l0cj9LzBt62prLsv6U1O1lhAkwOPxzCPZAcATnMJgqUNh/Yq1vS6cksOyK3SlsMeG2E4zTM30pxhYH/VvWT5obPddPuFvrhRraxxjLoxR/+AM7B3N3zMuIKeJ3YL4WbN7hilN+OcgU4I+cCGNQtWLmgZrE5a3hxDKNBbn3Zsd85yiDXE+JJdcTPF9TN6XFNKU5zzZ7IIvbonZl+UUWgBrQWJGbo92TUeQPyROkjPn27H2M9YD/Bqa4lHMtGFc+cVA+zmazbDnHdYvOE/aAwPT2KzoS309NLwEYEUIwr7WTJ0g1gZkDXMLYwpyPjMmN1xX5e4Yho2T3hNU69Q6Nv1itUpSC6F6kDv8rfbdy+fo7Jf2njVVFUceX3V6IAtXDAAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_assert/target/main.json b/crates/nargo_cli/tests/test_data/brillig_assert/target/main.json deleted file mode 100644 index e37c4ea5994..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_assert/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81WbQ6DIAyt4ueyeRYQUPjnVWaG97/Aks0IWSXul2XZS0hr1Pb1tTU2AHCBDfn7ZPBB8Cdv+TmIjC4WhwhEcftVAxbpQC5C7s/TJ/qWlCVsgOSDUm7snZDizns7G82VngcjjNBGP3ojpTPKjHa2I7dCSScWbaVbNuQEsRZPjNHVyA+bB/TDTMkZ8y2Qf/W29TOCUSF/IuJR0evES8S1RZxDPR1scx6uG29v/j3qHWiRxuxA33CvhoQfATgQIsQ+u0wFYawSaBfmF4tJyHm3mHjhiqh3Kxh6jromiPLEOnaQeFhTNCmFUDXQDX+qumv6Hu1+h/5Z0yziiPECFhQbR4sKAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_blake2s/target/brillig_blake2s.json b/crates/nargo_cli/tests/test_data/brillig_blake2s/target/brillig_blake2s.json new file mode 100644 index 00000000000..6264d439b0b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_blake2s/target/brillig_blake2s.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2d/ZPNVRzH33btsp4lSZKV9ODx3t299q7nxxAhhJCHZRFCCCGEEEIIIYQQQgghRDP9W53PODs+jv3tvM/M98x878xn9nzseO/78/7c+zoYe/dfAP/h6aOeqQL7saHqC5y+0OnrO32R7YusbpGjX2h/T5H6tWJHo4HTN3T6Eqdv5PSNnb6J0zd1+mZO39zpWzh9S6d/yelbOf3LTt/a6V9x+jZO/6rTt3X615y+ndO/7vTtnf4Np+/g9KVO39Hp33T6Tk7/ltN3xrPnSD2rLw95HtTuvsTutbHdX1O7p+Z2Hy1t7q1svq1tjm1sXm1tLu3s/O3tnB3s1+tofXey/sRTofUD+7H2uQv1a/IYaD9m/B7ZejytTCiPBRF4LIzAY/0IPBYRPerXUak9v23qHVPvmnrPVBdTXU11M9XdVA9TPeVrm8qaKjNVbqrCVM5UL1OVpvKmqkz1NtXHVF9T/Uz1NzXAzjDI1GBTQ0wNNTUMzx7N7EdhTAGefxSr80BOFrli/q4yRcprifJcoGaUz9enft2yjHytQjz/qOf0A9W5vsq1iOolk2uCZ3cKlH6tv1KVT7HzOb372s81qGMW2otLaxY62uWZXhUVNZVlNdny7OxMWVV1PpepyFX3ymfz2Vw+N7csX15ek6/IV1ZVV1VmqrIV5TXZebmq8nlWvJjo822ir/d5vjKFdS0HfAgyPWu/w9W59kVRUMdzIgAsXnjuuTk2Q+AnfoglDQ+gOwK8J3+ouUfwd5SB8wQBMYcGxPnfIfoaifjgxPSs/X6gzimcPDVH2kDZuqOQbDjJ3KP4OwoKp4bE+d8l+hqN+ODE9Kz9fqjOKZw8NUfbQNm6Y5BsOMncY/g7CuJV/oQ3qg5d31zHIg4olxCzfI/oaxzigzLTs/b7kTqnUPbUHGcDZeuOR7KhLHOP5+8oiFe5PMaCD+UJiAPKjYhZdiH6moj4oMz0rP1+rM4plD01J9pA2bqTkGwoy9yT+DsK4lUujwngQ3ky4oByY2KWXYm+piA+KDM9a7+fqHMKZU/NKTZQtu5UJBvKMvdU/o6CeJXLYzL4UJ6GOKDchJhlN6Kv6YgPykzP2u+n6pxC2VNzug2UrTsDyYayzD2Dv6MgXuXymAY+lGciDig3JWbZnehrFuKDMtOz9jtbnVMoe2rOsoGydauRbCjL3NX8HQXxKpfHTPChPAdxQLkZMcseRF9zER+UmZ613xp1TqHsqTnXBsrWnYdkQ1nmnsffURCvcnnMAR/K8xEHlJsTs+xJ9LUA8UGZ6Vn7/UydUyh7ai6wgbJ1FyLZUJa5F/J3FMSrXB7zwYfyIsQB5RbELDNEX4sRH5SZnrXfz9U5hbKn5mIbKFt3CZINZZl7CX9HQbzK5bEIfCgvRRxQbknMMkv0tQzxQZnpWfv9Qp1TKHtqLrOBsnWXI9lQlrmX83cUxKtcHkvBh/IKxAHll4hZlhF9rUR8UGZ61n6/VOcUyp6aK22gbN1VSDaUZe5V/B0F8SqXxwrwobwacUC5FTHLcqKvNYgPykzP2u9X6pxC2VNzjQ2UrbsWyYayzL2Wv6MgXuXyWA0+lNchDii/TMyyguhrPeKDMtOz9vu1OqdQ9tRcbwNl625AsqEsc2/g7yiIV7k81oEP5Y2IA8qtiVnmiL42IT4oMz1rv9+ocwplT81NNlC27mYkG8oy92b+joJ4lctjI/hQ3oI4oPwKMcteRF9bER+UmZ6132/VOYWyp+ZWGyhbdxuSDWWZext/R0G8yuWxBXwob0ccUG5DzLKS6GsH4oMy07P2+506p1D21NxhA2Xr7kSyoSxz7+TvKIhXuTy2gw/lXYgDyq8Ss8wTfe1GfFBmetZ+v1fnFMqemrttoGzdPUg2lGXuPfwdBfEql8cu8KG8F3FAuS0xyyqir32ID8pMz9rvD+qcQtlTc58NlK27H8mGssy9n7+jIF7l8tgLPpQPIA4ov0bMsjfR10HEB2WmZ+33R3VOoeypedAGytY9hGRDWeY+xN9REK9yeRwAH8qHEQeU2xGz7EP0dQTxQZnpWfv9SZ1TKHtqHrGBsnWPItlQlrmP8ncUxKtcHofBh/IxxAHl14lZ9iX6Oo74oMz0rP3+rM4plD01j9tA2bonkGwoy9wn+DsK4lUuj2PgQ/kk4oBye2KW/Yi+TiE+KDM9a7+/qHMKZU/NUzZQtu5pJBvKMvdp/o6CeJXL4yT4UD6DOKD8BjHL/kRfZxEflJmetd9f1TmFsqfmWRsoW/cckg1lmfscf0dBvMrlcQZ8KJ9HHFDuQMxyANHXBcQHZaZn7fc3dU6h7Kl5wQbK1r2IZENZ5r7I31EQr3J5nAcfypcQB5RLiVkOJPq6jPigzPSs/f6uzimUPTUv20DZuleQbCjL3Ff4OwriVS6PS+BD+SrigHJHYpaDiL6uIT4oMz1rv3+ocwplT81rNlC27nUkG8oy93X+joJ4lcvjKvhQvoE4oPwmMcvBRF83ER+UmZ613z/VOYWyp+ZNGyhb9xaSDWWZ+xZ/R0G8yuVxA3wo30YcUO5EzHII0dcdxAdlpmft9y91TqHsqXnHBsrWvYtkQ1nmvsvfURCvcnncBh/K9xAHlN8iZjmU6Os+4oMy07P2+7c6p1D21LxvA2XrPkCyoSxzP+DvKIhXuTzugQ/lh4gDyp2JWQ4j+nqE+KDM9Kz9/qPOKZQ9NR/ZQNm6j5FsKMvcj/k7CuJVLo+H4EP5ScLnlv08qWNHDMjX+hVwyAtZQFKEp9BoYKqhqRJTjUw1NtXEVFM8fYE3N9XCVEtT8vMD5cdVyU9HkTfjl/d+lrcalXe2kzdSkvftkG8Tl+9KlG+Ckf9zLf/Fr9RUR1Py7+XyzzPyt4HOePHxP8lLWNF1uwAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_blake2s/target/main.json b/crates/nargo_cli/tests/test_data/brillig_blake2s/target/main.json deleted file mode 100644 index b904e3a0c52..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_blake2s/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"x":[1,2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_blake2s/target/witness.tr b/crates/nargo_cli/tests/test_data/brillig_blake2s/target/witness.tr index 2abb65d513e..09b25ee04e9 100644 Binary files a/crates/nargo_cli/tests/test_data/brillig_blake2s/target/witness.tr and b/crates/nargo_cli/tests/test_data/brillig_blake2s/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/brillig_calls/target/brillig_calls.json b/crates/nargo_cli/tests/test_data/brillig_calls/target/brillig_calls.json new file mode 100644 index 00000000000..bcb3bfd26b8 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_calls/target/brillig_calls.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1czW7bMAym7fgvadL/7hoMw4DtZMdJk9z8AHuEXVY0HbBd9hY77Z1Xt+L6hZGzIpZqtZCAQop+yI+yREo03SMiOqfHFNz/hSqf3v9FqiwT19UqL7qlMjBHq0C8IZSXKs9FfZMSKNeGcCTm56mIAWuukXOi2gcWnk8E/KbAcwB4YlXmviMNxoSeZKgN4iPNMyTghVgih7AMHMISO4Ql6BlLTru6L4f2GOpCMbZpK6E9VeVQQyfV9EPZMwuyI58afjOvIWBIHcASO4Rl4BCWyCEsocCSQzvuqVCMTcktm/XcPZ6S5mxUGwKPNEPDtEOgVRXX8/lmOduUVfmtmK1vVotivri5XpWrcrFa3M5WVbVZzVfL9c16WazLebUp7xbr6k4RiwzQ2tw9ppc6bEbmaG0dNgeaMh408dBhWiYSfOQ8TsjyYrXxkAYW6MZkbvHbkjs2/4wKIOn0nEa0rbVtYTZ44yw1cLvSLrlggfY/Hqic5Gm0SXzDDGnX+qF1bfbpe9p9VgGUQ9Un2tMnaKGDN10ezzddMjsnVm7tVpUvu2wSmMzmd/Mgp4JnZIE30zpw48/Uxi8TMqdEUjKrkKW7iMhphWRV2aeWcDbpl8pz2lUUb8Vt1yiDNreYjSsQaeaIgFebW6xvLEHPWNrcP/Jk33aF1F01uT2G/Ce0JxraqYY2uukkrv+5k2y40trcA8yrzZ3UF5bIISzSbRLQtvthSrvrK4I+H1U+VmMzMVau1wj6fIKxbToptzAvmGooM682ndQ3loFDWGKHsCQOYUkdwpI5hCXoGUubPeV2dLUOVRltZ6ihx7phCDTQnrL8OPZIlSMNv5EG15FmLM4lj6lVXnRLD3OJfGr4PQJ5A4GvTyyZQ1hSh7AkDmGJHcIycAhL5BCWUGAJoJ3Pc6yr8DzHfb6rnM+CYzE2hzGcc58fMDal7TuF7u6BOvU5dx2rr8tee5xSBuU/monl5OOU9iYfp2QRi49T8nFKsp+PU/JxSj5OqTtub7PsYPE2623arK/Q7m1WNyzeZnmbdQhub7PsYPE2623arN/Q7m1WNyzeZnmbdQhu/z2IhnYGtLpGXuYGaKnvQW5fyqmfm6O15dQfQtl/D9KRJr+mN013ROYWvy25R+afkdUQYZNz+hrf7EmsX1T+2t/osfXbF8Js4xMD0swRkf5WGfSMpe2WEIm5wrWAr8rxv1TobgmZhh+/YcVTDIZESQx4IuMxGdThGM4xZFXysB1ahnxqgYExBQJfn1hCDRYbp3Dm2aQp7Z6kcQ3lgFuGlMh1gSElH1Q+VnKMzcoxw9AYKccYsE9UGUNjjoUcvJYnIAf3+SzkODUrR9XgOSG9HKcgx5kqn4Ac50IO3n9nIAf3KYQcl2blmDd4LkgvxyXIcaXKFyDHOyEH64wrkIP7XIMcrt34EnraC7UZLA/rPGnBsu+G3ORDs1iqfboD9RmGwzIWw/t/fuj+b+pw/3Md7yvUgbz/UB7eWxOoY77HUMdr4gTqeO3gvpZ71qo3gAnrDsZ/AfPEEVbPSwAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_calls/target/main.json b/crates/nargo_cli/tests/test_data/brillig_calls/target/main.json deleted file mode 100644 index 91e3a0157d9..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_calls/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1czW7bMAym/+2kSf+7aw7DgO1kx0mT3PwAe4RdVjQdsF32FjvtnVe3IvqFlbMilmq1kIBCin7IjzIlijLdIyI6p8cU3P+FKp/d/0WqLBPXNSov+6UqMEerRLwhlFcqL0R9m1IoN4ZwpObnqUwAa6GRc6raYwvPJwJ+M+AZA55ElbnvWIMxpScZGoP4SPMMCXghlsghLLFDWBKHsAQDYyno+d5XQHsCdaEY27ZV0J6pcqihk2n6oey5BdmRTwO/mdcIMGQOYEkcwhI7hCVyCEsosBTQjmsqFGMzcstmvXSNZ6Q5GzWGwCPN0DDtEGjV5fVisV3Nt1VdfS/nm5v1slwsb67X1bparpe383Vdb9eL9Wpzs1mVm2pRb6u75aa+U8QiA7S2d4/ptQ6bkTlaO4fNWFPGgyYeOkzLRIKPnMcpWVZWGw8ptkA3IXPKb0vuxPwzKoGk03Ma0q6iOuxp7iw6AxgrLrQbhFXrwm4+70T8u2U6Ezwjiw/gQGWZK2WpUoOKl5HZRSyvGIjcvjaxiTOzhLNNv1VegK4GUPcernpa6911lWLj2EyaOSLg1XWVMjSWYGAsXVcG8jTY5Xbo3BNuTyD/Be2phnamoY1XOxLX/64gbFy/dLmUzKvrCmIoLJFDWKSrHdCuyzqj5/oVQZ9PKp+osbkYK/U1gj6fYWzXnlRYmBdMDZSZV9eeNDSW2CEsiUNYUoewZA5hyR3CEgyMpcuecjtez41UGW1nqKHHe8MIaKA9Zflx7JEqRxp+Yw2uI81YnEse06i87Jce5hL5NPB7DPIGAt+QWHKHsGQOYUkdwpI4hCV2CEvkEJZQYAmgnc9zvFfheY77/FA5nwUnYmwBYzjnPj9hbEa7PoXO98A99SW+jtVLsLce25JD+a9mYjn52Ja9yce2WMTiY1t8bIvs52NbfGyLj23pj9vbLDtYvM16nzbrG7R7m9UPi7dZ3mYdgtvbLDtYvM16nzbrD7R7m9UPi7dZ3mYdgtt/Q6ChnQOtvpGXhQFa6huC29e61C/M0dq51B9B2X9D0JMmv6Y3TXdM5pTfltxj88/IaoiwyTl9i2/2JNavKn/rb/TY+u0LYbbxiQFp5ohI71UGA2Pp8hIiMVeoC/iqHP+zgc5LyDX8+A0rnmIwJEpiwBMZj8mhDsdwjiGrkoft0DLk0wgMjCkQ+IbEEmqw2DiFM882zej5SRp1qADcMqRE6gWGlHxU+UTJMTErxxxDY6QcE8A+VWUMjTkWcrAuT0EO7vNFyHFqVo66xXNCejlOQY4zVT4BOc6FHLz+zkAO7lMKOS7NyrFo8VyQXo5LkONKlS9Ajg9CDt4zrkAO7nMNcrjm8aX0tBYaM1ge9DztwLLPQ27zkVks9b69A/czDIdlLIbX/+LQ9d/W4frnOl5XuAfy+kN5eG1NoY75HkMd68QJ1LHu4LqWa9b6N59E+oPxPw/GFGwDSgAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_calls_array/target/main.json b/crates/nargo_cli/tests/test_data/brillig_calls_array/target/brillig_calls_array.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_calls_array/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_calls_array/target/brillig_calls_array.json diff --git a/crates/nargo_cli/tests/test_data/brillig_calls_conditionals/target/main.json b/crates/nargo_cli/tests/test_data/brillig_calls_conditionals/target/brillig_calls_conditionals.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_calls_conditionals/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_calls_conditionals/target/brillig_calls_conditionals.json diff --git a/crates/nargo_cli/tests/test_data/brillig_cast/target/main.json b/crates/nargo_cli/tests/test_data/brillig_cast/target/brillig_cast.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_cast/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_cast/target/brillig_cast.json diff --git a/crates/nargo_cli/tests/test_data/brillig_conditional/target/brillig_conditional.json b/crates/nargo_cli/tests/test_data/brillig_conditional/target/brillig_conditional.json new file mode 100644 index 00000000000..0f2df0bdcc0 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_conditional/target/brillig_conditional.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9VWUU7EIBCdQrvdatLEm0CBLfx5FRvp/S9g1HUh+4rVnx2MOwmBAn3z5g1MeySiB7qYTK20JvXPqVe3mW74sNQOXS7sqSK2FoApQP9sA6zl9QPkI+9tP9s7fc9VA2OR9shf9jQ/4Awwl98fgQvxaaIOxH7W1AiY3IS/DnJO0FtyJJJQpVNZwXfGMupkbZynqI1+UVNYvFPWLSevvXbevU7emOitn8MSZhW0NVGvLpi4XkwwYK2JmOSLUe3pSPyHRHNyRr4tjJ9SP9D1Qme7l8vUAVcsDDme82WT8PwIOhwh1paXlxtoWxBzP4LPjtenRZ/djs+BrlpJmCuLeU8VCxRiigL71oveMmJ1jIn5q6LByHlTNLAYtEXuziZhH3dMVPgpdaz6Na2VpBpC9cR3+GvF3fPnaPO7/Z81bQqOaB8buBOz8wwAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_conditional/target/main.json b/crates/nargo_cli/tests/test_data/brillig_conditional/target/main.json deleted file mode 100644 index c40c6906e2f..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_conditional/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81W0Y6DIBBcAWu9S0zuT0Cgwlt/5czh///AJXdGjFvSPnVoOgkBjdmZnV02nonogzaI/9XQgf18zbt+DqbBxdJUABR3XD2QhQ9wE0Rev5noEamsWACrL86laUzGmm89xjl47fx8CSYYH/zPGKxNwYUpznHS0TibzOKjTcsGAYi1ZGESl6O+WzzCNzNSM9er2Pkr733uEY4TO19BOk54n3TLtPZM857PQFuf78+fzIczy1Vhdfmejvul2D4wzhbL6Thne4ezp8Mryd4JpmlFRxUHFI8pitjPXnQFjNUCC/OqoQHUfDM0+DBQRe1WSPYdOicqeEofB6rcrDWKVMOojnDNXyvvDl+jm1+1d/a0KTRy/AEWFX4ZJwsAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_ecdsa/target/main.json b/crates/nargo_cli/tests/test_data/brillig_ecdsa/target/brillig_ecdsa.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_ecdsa/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_ecdsa/target/brillig_ecdsa.json diff --git a/crates/nargo_cli/tests/test_data/brillig_field_binary_operations/target/main.json b/crates/nargo_cli/tests/test_data/brillig_field_binary_operations/target/brillig_field_binary_operations.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_field_binary_operations/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_field_binary_operations/target/brillig_field_binary_operations.json diff --git a/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/brillig_fns_as_values.json b/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/brillig_fns_as_values.json new file mode 100644 index 00000000000..8c02dc4b741 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/brillig_fns_as_values.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/main.json b/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/main.json deleted file mode 100644 index a3d5138e69c..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_fns_as_values/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_hash_to_field/target/main.json b/crates/nargo_cli/tests/test_data/brillig_hash_to_field/target/brillig_hash_to_field.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_hash_to_field/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_hash_to_field/target/brillig_hash_to_field.json diff --git a/crates/nargo_cli/tests/test_data/brillig_identity_function/target/main.json b/crates/nargo_cli/tests/test_data/brillig_identity_function/target/brillig_identity_function.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_identity_function/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_identity_function/target/brillig_identity_function.json diff --git a/crates/nargo_cli/tests/test_data/brillig_identity_function/target/c.json b/crates/nargo_cli/tests/test_data/brillig_identity_function/target/c.json deleted file mode 100644 index 09089ad1fa0..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_identity_function/target/c.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":[213,148,77,78,195,48,16,133,67,211,150,180,92,198,142,237,198,222,241,183,97,193,170,39,32,197,45,150,210,164,10,86,246,190,129,99,195,142,29,80,4,167,224,26,220,6,132,40,82,215,30,36,227,149,87,79,51,223,188,247,238,142,30,204,203,105,171,170,74,173,238,123,179,157,171,122,85,73,111,123,247,113,140,194,30,62,8,150,64,223,19,173,55,149,28,88,103,30,47,155,206,37,201,211,92,55,155,119,243,118,210,42,125,179,150,90,45,188,245,16,227,126,105,16,52,163,84,22,185,196,4,95,161,92,148,156,33,202,202,25,199,28,51,206,174,115,78,136,228,148,23,162,20,5,18,152,18,137,151,76,144,229,143,200,0,64,35,13,199,102,94,207,85,43,23,90,117,210,108,47,234,78,182,218,165,195,61,100,189,15,39,150,14,33,108,50,10,71,6,191,217,200,2,92,97,207,162,177,160,250,77,187,139,46,237,209,13,228,118,245,51,222,125,14,173,55,207,103,77,125,171,93,210,3,108,252,15,58,109,12,160,145,253,77,167,101,19,240,228,103,19,8,239,77,35,236,180,108,26,101,167,1,160,178,246,19],"proving_key":[0,0,0,2,0,0,0,16,0,0,0,0,0,0,0,69,0,0,0,3,113,95,49,0,0,0,16,254,255,255,31,216,20,60,120,221,30,141,12,111,47,152,175,69,79,253,252,146,116,95,143,172,191,156,61,26,99,55,31,128,225,166,19,57,49,226,241,25,0,192,25,68,134,248,118,168,148,147,77,202,252,253,191,232,34,128,93,159,247,134,11,76,135,16,63,22,220,90,11,47,238,136,127,221,224,11,208,111,8,212,89,138,92,85,171,215,86,38,230,32,230,222,31,153,33,17,244,110,182,83,120,134,226,119,20,11,135,137,123,161,100,228,245,184,170,239,230,246,84,3,136,168,13,61,27,248,206,237,196,3,251,75,41,174,251,100,247,192,65,80,218,6,170,55,30,58,230,35,74,112,242,201,88,196,129,110,17,96,38,159,136,213,223,121,213,54,117,35,89,161,79,59,216,138,170,79,239,53,218,90,140,178,58,7,148,89,158,24,43,67,130,113,165,31,169,220,202,57,163,114,96,117,84,13,60,219,59,7,119,225,98,253,63,194,166,143,84,101,143,134,15,107,124,191,58,95,120,167,216,11,221,18,255,243,153,72,60,90,224,46,241,29,149,154,104,198,48,50,19,159,157,25,14,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,16,144,128,125,98,191,216,133,187,137,8,118,247,57,246,102,212,73,23,253,117,193,54,186,171,54,248,235,240,215,4,156,49,180,120,239,192,233,35,165,244,208,17,119,128,34,31,244,47,144,247,43,166,117,163,170,84,40,169,217,25,223,25,33,0,89,124,202,117,192,42,8,98,248,245,196,205,7,205,126,137,38,160,141,73,40,173,248,29,61,208,243,235,197,146,104,8,7,49,18,75,104,15,210,146,192,147,225,142,246,213,123,253,155,253,70,96,15,212,139,253,101,109,4,198,200,47,45,30,176,59,133,237,34,42,238,215,108,147,18,184,220,44,36,115,103,1,65,212,85,89,93,223,108,224,100,186,29,94,10,18,189,125,142,90,224,86,35,53,198,92,141,159,138,171,242,195,36,196,248,136,30,157,2,192,61,89,112,171,154,112,121,16,135,33,28,47,208,104,180,1,115,251,41,227,30,186,191,200,109,36,67,78,195,194,77,156,109,244,196,96,207,2,140,21,0,0,0,7,113,95,49,95,102,102,116,0,0,0,68,33,185,35,19,211,157,207,139,200,46,221,191,180,55,39,213,48,163,198,132,183,226,65,68,111,162,151,156,210,60,242,13,148,91,186,43,24,55,242,122,66,221,229,167,113,20,234,13,143,145,118,167,100,213,71,238,124,57,101,183,220,182,200,67,120,63,57,25,70,66,110,174,121,229,156,239,77,134,12,201,125,213,220,253,186,105,169,13,98,30,193,173,124,67,58,33,53,115,110,187,211,17,50,156,69,228,249,17,68,21,237,84,139,99,114,224,156,55,94,27,79,187,184,165,141,60,53,42,86,126,164,210,4,9,76,201,0,65,178,27,107,212,0,26,53,227,74,231,54,96,211,189,197,121,183,105,97,124,105,11,176,0,98,20,159,190,180,71,33,186,83,132,202,105,144,22,49,166,5,77,178,185,111,48,200,157,111,93,250,235,165,19,126,89,119,45,5,136,54,245,228,23,192,144,107,190,48,75,79,33,98,25,34,253,246,31,37,177,64,11,227,95,220,15,240,192,118,220,113,6,8,240,84,115,105,170,23,175,16,225,100,62,50,233,71,41,46,128,5,211,142,82,1,222,250,63,81,249,197,143,108,138,117,169,78,95,135,155,0,65,66,53,191,243,148,232,57,153,192,159,213,189,87,93,89,121,82,19,198,28,172,188,160,31,140,137,31,130,117,233,8,20,115,214,158,22,53,68,18,112,202,179,120,62,74,188,133,123,215,85,180,248,189,188,200,46,239,162,59,142,45,158,128,83,231,100,120,28,204,98,79,188,151,231,20,37,147,136,97,188,61,17,91,4,18,179,71,17,99,84,228,123,163,9,155,135,21,246,38,98,86,225,240,22,243,42,134,6,140,81,67,118,31,63,224,200,32,138,139,111,243,208,47,46,106,197,218,2,198,165,189,38,80,57,97,164,255,22,144,169,45,210,70,201,253,22,50,19,98,42,9,255,76,28,187,215,10,61,43,221,32,133,236,130,161,57,8,111,57,100,71,2,205,105,51,31,30,8,71,137,7,213,86,39,99,44,161,208,185,167,85,60,165,17,24,230,255,39,200,70,58,56,129,143,120,178,153,43,115,77,235,141,164,123,121,7,142,182,146,137,229,85,213,15,209,175,216,149,25,101,163,85,145,194,106,31,125,40,192,15,171,58,100,27,58,246,109,72,77,237,152,140,229,245,159,171,33,10,106,10,130,121,165,31,239,39,252,211,103,1,94,151,149,14,59,242,5,129,116,218,122,232,164,34,128,49,59,94,24,66,241,147,202,70,29,97,187,111,172,57,91,53,210,63,94,53,104,164,32,46,180,78,172,149,112,88,88,21,254,219,63,192,242,196,129,56,232,178,230,212,64,57,25,67,50,45,21,33,227,254,214,108,119,60,103,253,163,178,37,239,6,134,93,231,22,143,0,229,16,240,215,176,156,39,27,163,53,224,193,11,93,226,151,235,173,250,204,41,5,113,57,201,77,171,24,22,141,79,202,226,164,172,13,157,9,38,180,204,221,222,80,60,233,93,210,15,64,87,53,123,55,114,75,95,56,255,215,108,242,34,148,253,209,250,124,26,217,254,249,218,64,59,158,6,118,119,162,21,51,12,98,172,179,124,12,158,122,2,49,9,181,173,243,235,60,124,199,150,185,179,105,23,93,190,134,21,142,226,57,155,132,1,94,158,219,148,121,241,17,180,147,148,236,212,178,145,255,135,9,179,245,216,182,129,115,194,162,37,165,205,139,74,177,207,250,245,7,38,91,182,128,117,253,18,33,158,72,145,185,238,190,228,6,61,211,37,196,220,223,76,206,81,47,33,165,105,42,199,234,38,13,27,149,128,249,110,63,144,224,254,45,177,66,166,74,73,3,96,100,54,9,56,107,46,139,119,226,188,195,17,28,81,168,98,3,14,65,226,102,250,102,200,39,88,230,52,109,77,225,86,1,238,194,85,131,22,25,37,210,226,95,81,148,198,28,219,139,57,201,123,126,224,36,200,192,223,113,141,224,163,195,81,122,132,72,16,53,54,240,143,35,54,79,193,152,95,166,68,144,76,122,241,212,20,254,60,244,10,58,209,140,115,196,206,69,91,227,79,184,118,219,0,14,223,0,136,32,171,196,244,135,60,232,86,62,132,27,152,13,80,229,50,201,16,73,126,220,3,6,88,130,172,66,32,8,51,143,222,45,124,229,133,186,66,99,131,239,163,113,147,193,32,205,202,122,206,221,241,63,253,184,56,57,77,150,4,201,85,138,29,9,236,36,8,132,165,159,128,149,96,208,107,32,11,128,249,74,188,105,142,87,253,224,15,135,104,199,210,120,101,47,225,151,0,242,186,118,152,66,188,111,95,249,158,131,30,79,193,139,226,87,187,49,245,27,5,184,197,86,213,60,125,117,52,186,140,4,43,232,51,230,189,208,198,47,114,191,210,112,149,82,28,111,254,120,6,88,25,140,206,30,5,137,127,29,139,32,104,57,93,203,249,2,225,74,108,239,64,250,96,146,7,227,18,216,6,182,100,149,78,39,55,191,34,47,230,72,165,139,184,63,24,28,157,182,221,243,43,231,144,31,56,188,46,229,127,226,61,217,133,37,19,50,1,158,16,245,128,229,178,26,76,29,74,1,80,128,161,251,19,169,18,245,36,175,222,149,95,93,77,53,47,35,10,2,153,130,136,52,112,208,173,1,209,12,123,197,128,60,186,43,127,119,55,211,201,147,46,125,7,241,201,99,155,141,9,118,98,128,26,4,10,130,215,8,106,6,92,192,39,250,238,53,234,188,33,189,192,18,81,244,51,0,209,57,23,231,40,6,173,61,33,129,246,35,158,167,58,21,168,137,75,168,90,217,205,154,229,185,169,144,124,178,105,138,154,225,71,70,59,247,8,216,140,23,216,14,168,2,131,224,217,21,249,78,174,10,112,117,5,81,128,150,11,160,228,136,230,223,81,185,17,198,54,80,131,102,94,76,73,234,95,141,47,100,100,117,20,0,204,18,144,68,144,76,247,150,225,78,60,138,3,16,58,104,255,254,223,186,47,237,231,247,174,184,58,125,21,100,65,18,228,2,48,137,6,170,197,255,28,169,15,62,234,240,62,89,122,99,83,19,44,209,227,243,254,183,0,104,189,27,65,55,77,26,194,182,36,238,116,250,93,152,159,69,138,55,74,186,84,150,26,128,214,171,122,146,185,106,139,47,85,75,103,51,142,140,175,117,114,160,36,189,79,69,161,119,5,15,50,192,139,4,135,23,176,212,36,228,248,115,193,227,49,198,108,180,67,234,247,30,19,58,107,254,171,222,152,254,204,236,40,1,1,125,119,245,5,171,30,215,214,191,237,38,216,63,208,46,123,187,63,189,204,226,65,112,91,235,21,21,62,220,3,129,79,176,224,193,38,110,52,28,206,148,106,66,159,82,210,224,166,4,250,219,16,138,115,127,142,251,234,157,0,230,60,162,170,25,153,71,247,35,225,167,153,99,216,15,13,195,39,76,194,10,80,125,90,170,87,94,25,179,84,64,64,191,30,91,210,207,206,18,101,155,3,31,180,58,221,212,163,232,79,247,30,116,107,171,127,10,133,81,70,232,112,69,222,91,89,168,57,58,71,177,118,200,156,239,197,55,147,209,41,119,24,42,179,239,43,86,191,248,143,190,195,117,118,204,132,123,49,15,146,74,93,77,184,32,204,12,34,37,128,137,191,199,180,15,236,217,65,151,206,73,3,101,63,134,247,216,61,140,72,217,193,23,17,162,9,110,230,128,247,28,191,248,248,27,21,178,214,209,180,75,21,179,27,154,235,171,63,160,9,153,45,109,102,6,4,224,153,137,63,7,109,168,107,229,219,79,234,2,204,154,252,134,28,108,64,40,19,103,24,214,146,128,54,14,225,134,217,136,67,112,224,72,57,223,210,120,154,186,94,250,111,227,249,119,150,35,162,163,74,6,125,6,250,70,58,120,158,66,45,41,100,236,147,64,94,158,77,45,43,155,220,241,156,156,223,191,24,43,26,65,231,240,71,5,99,73,74,117,208,182,35,136,139,144,130,134,15,32,76,52,138,142,125,53,16,175,21,60,123,230,133,108,44,127,189,50,130,140,29,112,109,84,123,222,224,68,181,101,246,63,225,125,76,36,97,201,232,210,149,13,201,36,149,215,205,205,48,94,100,11,54,225,175,228,40,42,76,96,254,203,42,123,172,162,135,218,204,109,197,214,133,33,18,122,186,142,142,18,228,101,21,197,85,65,160,222,2,120,194,94,207,114,100,96,237,76,209,76,191,203,187,229,12,118,25,78,8,252,61,198,55,180,204,74,37,67,0,71,235,73,66,230,228,89,67,53,132,252,198,213,220,173,43,27,150,105,225,178,248,176,36,226,254,183,63,52,11,136,147,153,15,112,164,224,182,2,107,157,238,116,199,30,97,104,64,169,91,228,122,150,44,110,56,189,159,145,205,149,72,40,242,55,43,27,222,227,144,152,16,169,76,192,9,46,11,218,93,111,56,134,124,60,66,139,210,170,180,173,109,31,69,127,117,39,162,231,88,26,238,12,149,151,220,90,242,254,249,207,148,34,189,210,162,108,26,12,108,103,207,22,125,157,82,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,49,95,108,97,103,114,97,110,103,101,0,0,0,16,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,241,255,255,239,84,156,194,5,125,103,34,222,192,99,245,164,138,210,107,105,78,234,75,51,142,157,23,206,68,103,31,42,0,0,0,3,113,95,50,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,25,30,64,95,235,13,171,42,228,62,124,180,116,227,178,31,242,75,250,39,219,137,233,73,73,35,134,47,44,128,193,13,16,95,107,169,29,208,35,15,148,61,97,255,209,43,101,21,149,96,197,119,184,208,113,228,116,30,51,136,214,50,41,21,111,117,214,118,104,98,247,124,0,96,41,18,65,95,219,179,255,65,91,75,226,130,203,107,91,164,76,236,179,14,239,9,212,217,146,93,102,184,79,7,90,168,67,179,167,43,177,190,157,93,83,187,54,124,24,158,72,47,130,153,101,68,40,10,7,239,61,66,191,100,68,213,61,129,232,151,28,172,32,30,118,203,35,145,171,127,81,231,71,143,247,102,59,94,184,22,90,88,151,124,55,133,103,230,173,36,191,209,204,96,52,192,183,138,10,245,80,178,220,122,201,243,53,92,126,243,160,31,232,34,162,159,159,221,237,151,85,165,246,161,139,141,232,98,43,182,194,210,58,27,39,142,63,207,123,223,130,228,5,5,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,16,232,225,191,144,168,231,54,25,173,49,61,197,211,4,129,8,107,12,135,89,219,187,102,110,224,124,171,177,70,206,162,34,241,160,148,70,118,37,190,52,253,50,88,122,118,188,206,18,200,247,187,9,254,116,222,211,180,129,254,88,156,27,59,27,146,138,41,121,43,147,234,198,144,16,144,103,7,137,88,116,93,22,38,54,212,194,132,76,206,251,228,244,190,63,117,38,45,38,109,146,45,61,146,60,55,200,117,198,160,188,130,105,191,250,45,198,127,201,55,26,225,112,175,71,13,10,60,38,250,16,194,173,212,144,157,110,83,239,208,225,43,60,19,10,231,140,93,240,10,198,254,208,225,16,58,122,55,240,171,25,167,167,104,115,92,112,122,93,227,75,250,167,123,135,255,103,165,205,118,140,101,147,115,61,96,172,251,132,244,90,195,16,25,221,93,80,244,23,244,171,59,203,194,215,188,90,75,197,49,162,190,174,123,42,41,42,234,208,181,1,240,105,94,43,0,0,0,7,113,95,50,95,102,102,116,0,0,0,68,92,65,127,181,198,89,181,35,146,85,92,92,53,240,231,147,60,119,25,190,180,125,35,91,48,246,224,163,214,202,162,27,145,123,194,11,154,75,4,55,101,141,212,229,235,31,99,254,141,106,93,178,27,19,147,195,239,206,181,44,222,117,225,93,35,85,255,121,208,180,244,170,171,48,218,21,86,184,110,224,32,6,150,209,32,18,211,210,120,134,44,224,67,34,3,44,32,72,65,9,100,147,157,236,222,125,150,200,185,20,145,243,175,110,131,244,23,106,90,184,213,185,197,92,70,248,9,53,178,202,57,54,172,14,138,189,169,125,191,11,80,145,49,225,251,116,238,187,210,202,150,101,104,68,40,121,112,206,13,45,166,94,137,5,44,178,46,14,61,142,147,80,14,128,213,114,237,244,126,154,77,154,143,175,115,183,7,78,26,89,251,74,164,232,229,35,232,195,27,160,222,11,84,26,176,130,36,147,121,10,111,178,32,40,201,175,192,243,12,51,64,42,118,57,175,80,118,46,64,122,251,212,219,126,141,2,158,189,67,120,154,209,54,44,13,168,43,16,225,71,252,144,11,222,169,41,127,214,158,135,92,166,221,131,172,228,234,146,92,215,70,65,129,231,61,96,32,162,31,226,42,136,59,176,227,215,223,7,144,245,233,170,191,98,210,46,173,197,43,245,43,191,201,68,213,193,196,109,85,224,253,237,251,1,37,26,123,33,79,22,241,170,128,183,54,228,37,56,152,109,205,113,209,113,83,182,56,15,142,34,170,179,108,32,85,55,135,217,26,52,123,36,34,108,70,219,222,170,97,66,10,161,119,156,119,192,21,204,104,241,22,159,218,255,80,201,230,131,147,208,146,195,137,68,157,167,77,201,199,231,250,34,33,189,96,53,33,14,70,0,46,36,97,149,178,211,238,148,86,178,219,2,254,6,11,32,117,240,127,47,182,61,72,14,50,96,70,155,153,44,218,11,31,71,107,9,174,3,174,177,108,50,116,35,33,147,84,89,38,215,106,107,7,204,24,115,212,116,61,240,171,42,28,43,62,171,94,199,45,68,147,225,29,245,51,197,4,112,1,22,252,163,161,37,253,202,199,236,172,192,202,246,14,123,193,3,77,145,5,53,156,71,44,168,6,124,230,181,94,24,208,36,35,64,186,237,177,101,122,119,108,15,158,8,105,183,3,113,126,187,222,146,159,123,15,122,196,125,62,137,141,245,90,21,210,1,22,186,35,58,178,1,85,8,238,106,163,194,179,201,27,213,19,9,126,10,156,140,139,44,206,59,132,181,226,33,38,36,166,251,58,129,46,186,189,153,122,218,173,233,122,28,95,152,130,13,161,18,9,174,79,144,77,148,134,246,88,19,166,131,73,113,20,111,158,109,173,0,46,112,251,168,151,67,252,150,253,162,42,190,38,121,76,135,161,80,107,194,4,3,237,130,251,48,137,176,229,17,235,86,132,174,81,155,13,176,96,133,166,163,104,150,135,112,251,243,203,143,248,237,166,32,145,71,252,57,12,166,105,141,254,109,22,66,100,172,184,132,147,156,148,250,43,66,176,133,227,184,184,199,125,46,117,16,225,249,172,200,251,236,86,175,57,125,205,182,94,143,12,114,100,50,198,56,129,228,238,127,50,156,25,89,178,129,154,74,39,103,232,180,74,211,114,65,188,12,125,197,69,187,28,179,254,240,157,223,161,68,31,136,55,8,53,154,153,235,156,45,7,6,146,246,0,195,40,93,158,14,73,145,125,95,32,119,112,8,62,96,216,141,26,49,119,173,80,82,211,147,21,45,1,53,97,201,200,81,44,96,130,114,113,59,232,216,22,51,164,255,238,211,39,233,99,139,194,25,61,53,224,107,140,60,20,33,108,58,240,120,199,152,101,70,106,149,209,17,42,112,218,232,99,22,14,18,23,68,96,165,2,113,167,88,233,56,78,33,148,85,69,225,254,14,33,24,141,20,234,130,20,174,34,250,204,134,213,47,189,145,37,49,185,96,159,217,46,11,83,217,253,12,39,179,158,122,35,58,183,25,180,225,6,109,81,172,235,100,228,133,98,181,252,243,26,119,252,122,231,42,152,73,82,10,0,188,11,150,98,91,136,221,43,49,189,111,14,25,16,206,226,228,73,220,68,69,250,224,177,155,85,57,31,243,147,197,26,116,216,62,121,179,53,56,5,216,234,211,118,112,121,198,77,82,206,39,31,32,120,19,41,174,216,91,196,142,47,163,4,227,174,163,182,56,171,179,115,185,253,47,84,152,249,206,2,46,145,74,78,193,190,115,233,94,138,39,188,115,75,178,145,78,228,200,121,197,72,198,172,121,28,59,241,53,159,123,93,31,150,71,168,203,185,160,95,72,227,2,177,223,188,67,179,247,250,216,67,177,64,142,29,191,31,72,75,189,184,146,189,182,239,252,148,205,181,221,92,30,111,2,185,134,79,36,138,12,255,64,173,235,217,127,75,42,17,138,163,200,199,227,201,64,79,123,70,121,167,162,19,70,194,89,34,66,226,117,83,171,0,150,111,201,236,27,92,34,148,62,5,66,231,57,126,90,78,136,124,230,205,98,8,20,251,80,48,133,135,41,153,32,231,28,37,87,156,208,233,181,3,129,8,138,41,179,248,223,248,249,135,41,192,28,11,43,254,65,172,107,204,107,138,11,180,18,219,240,139,231,163,22,130,51,79,86,172,37,196,219,195,112,23,185,117,180,5,253,80,1,154,216,235,109,208,174,196,48,29,96,16,44,225,64,7,134,183,228,69,129,227,21,136,132,214,217,172,167,59,47,155,17,27,136,212,83,157,249,185,39,211,204,64,225,139,164,146,200,124,216,138,210,198,56,103,182,165,215,202,159,227,198,180,63,109,8,52,83,60,252,218,230,212,106,152,22,235,185,22,71,80,107,182,160,150,84,53,220,108,144,212,176,200,239,155,25,150,186,63,159,3,207,249,24,26,41,40,201,207,251,132,132,95,33,24,231,159,33,205,69,110,164,110,212,231,200,139,56,145,97,109,43,8,69,165,199,214,63,35,43,228,224,46,169,193,220,115,37,246,78,13,82,25,71,246,79,215,215,23,41,54,143,221,47,142,96,58,250,226,244,153,106,255,69,37,251,7,202,148,29,22,38,111,201,88,158,184,170,212,56,117,26,197,128,190,160,93,120,51,58,203,234,63,190,181,45,20,226,66,212,150,8,49,53,146,175,233,220,106,27,83,35,249,80,231,223,205,216,92,51,234,101,40,54,167,79,66,219,187,210,206,82,135,34,225,49,39,133,11,168,199,139,115,92,78,61,176,184,244,237,156,204,3,75,133,221,18,165,12,100,162,163,12,44,29,34,198,200,211,159,59,47,233,148,106,154,242,53,218,224,70,84,74,142,147,210,231,214,234,98,79,87,194,200,73,217,99,129,239,74,121,132,4,215,69,64,197,108,216,73,239,235,16,100,134,83,216,37,234,151,114,244,45,139,15,118,12,114,139,145,241,192,107,51,198,150,72,211,250,61,59,95,198,231,212,67,193,24,84,239,11,165,74,63,172,12,24,213,207,1,30,251,133,81,73,185,23,187,33,81,114,2,105,53,190,59,219,154,126,243,190,167,134,138,41,39,111,129,53,137,116,110,176,28,117,151,99,5,149,241,93,36,85,210,184,40,108,166,182,104,29,21,70,178,212,236,56,217,87,214,76,64,15,36,34,114,157,227,86,56,188,114,150,104,173,47,54,36,221,128,172,34,103,134,150,32,225,231,73,202,61,232,84,153,221,220,19,247,38,250,121,160,27,105,121,173,11,181,104,65,211,54,123,6,195,120,150,159,63,198,31,81,232,79,101,44,242,181,120,203,168,192,158,29,11,90,172,157,107,17,226,40,197,22,86,85,139,241,173,79,135,49,35,113,19,165,186,37,85,194,71,98,145,173,32,157,178,39,151,186,251,99,192,55,115,0,121,189,13,21,169,97,182,99,124,141,247,20,23,15,124,146,234,170,115,15,31,132,187,168,110,105,47,108,62,76,5,194,36,85,251,125,149,121,53,55,131,245,128,122,124,85,9,226,17,222,128,135,39,81,187,36,56,86,168,21,59,85,185,206,113,236,191,16,35,248,184,26,6,135,163,1,250,105,106,90,223,215,127,194,201,173,242,138,12,123,19,157,79,76,52,89,181,158,152,132,232,214,149,24,225,187,61,134,39,43,240,164,102,91,97,40,1,115,42,105,15,188,179,184,63,27,220,159,224,28,16,121,247,179,150,61,107,190,137,140,245,152,204,186,193,161,134,2,62,162,110,253,51,183,236,68,106,63,129,34,109,181,167,23,106,95,226,116,94,52,14,161,196,154,107,67,232,91,3,103,0,230,52,113,124,113,23,64,161,29,162,164,43,142,96,141,9,158,71,150,115,167,203,97,192,255,103,133,217,62,116,59,191,7,124,78,216,24,217,117,106,61,163,232,87,224,156,6,21,13,208,53,233,24,110,218,150,146,37,151,242,240,221,56,42,44,104,220,26,89,110,144,141,73,50,59,127,183,73,0,91,242,132,246,59,142,37,231,92,45,145,5,150,209,35,238,247,78,248,240,206,156,144,220,20,82,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,50,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,255,255,79,221,218,118,110,21,196,201,3,14,242,189,179,91,192,99,96,7,72,106,225,147,220,237,134,147,144,197,7,0,0,0,3,113,95,51,0,0,0,16,255,255,255,15,108,10,30,188,110,143,70,134,183,23,204,215,162,167,126,126,73,186,175,71,214,95,206,30,141,177,155,31,47,105,2,24,44,61,202,225,13,32,123,108,193,107,94,173,50,114,254,198,176,90,125,164,150,196,246,249,175,17,22,17,212,54,198,19,37,196,236,18,249,140,57,127,198,118,190,90,186,184,182,149,230,68,142,29,18,230,63,42,140,127,115,26,78,45,231,99,47,178,137,217,194,249,98,34,71,84,65,171,26,157,214,254,238,114,188,4,251,25,142,7,130,73,178,23,206,168,128,2,146,158,95,184,42,133,27,158,249,61,105,233,94,184,141,220,221,237,220,88,12,98,175,180,15,99,95,44,93,116,146,10,202,247,15,36,96,11,13,172,211,201,170,103,94,130,48,250,24,93,230,138,166,181,221,0,246,156,82,51,112,46,189,99,187,107,16,190,144,53,82,201,219,132,39,28,55,129,140,241,9,188,107,253,166,160,170,130,36,9,87,15,98,165,197,232,147,116,194,27,177,68,144,136,185,158,85,207,109,211,99,97,22,122,34,230,200,37,248,167,98,90,176,35,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,32,29,59,252,68,189,13,82,103,98,31,174,164,55,182,8,16,132,240,26,4,129,169,43,228,115,82,6,117,152,41,233,4,45,201,57,220,110,49,245,48,152,227,127,250,129,113,117,205,162,159,202,235,207,0,194,154,23,186,241,182,230,206,240,21,255,118,23,233,77,142,116,179,62,182,127,104,250,181,89,58,249,29,196,77,249,214,60,60,57,157,160,72,57,64,177,46,53,87,127,205,41,66,70,19,137,204,16,207,223,122,50,143,184,80,246,167,69,227,19,208,112,126,229,238,72,136,205,36,89,231,110,120,116,168,151,26,82,150,60,54,196,228,85,43,165,203,184,61,34,42,17,93,162,115,136,82,167,196,118,23,145,209,66,140,216,137,209,133,0,59,103,176,108,99,12,12,38,215,244,143,172,137,228,186,130,255,134,94,78,69,13,33,84,182,59,154,170,43,229,34,1,93,185,89,222,15,171,195,149,122,133,214,36,13,213,1,128,3,110,171,58,7,25,39,0,0,0,7,113,95,51,95,102,102,116,0,0,0,68,96,235,41,49,136,78,16,56,49,164,6,15,31,30,12,18,215,50,132,7,160,167,165,108,130,110,90,163,189,88,175,57,210,214,50,20,15,197,65,137,142,188,120,64,210,22,214,36,208,41,66,170,232,165,94,141,194,42,100,67,44,247,217,71,29,106,78,42,31,106,26,190,167,163,150,239,86,136,163,158,188,178,190,138,81,230,40,137,10,6,129,47,114,202,151,75,77,7,134,206,202,14,41,115,184,238,243,40,6,95,129,76,66,188,13,149,114,94,31,30,208,113,85,34,47,178,126,72,111,92,150,127,203,108,215,120,30,128,204,2,108,158,145,169,250,194,13,236,127,159,233,87,124,168,138,238,238,244,194,88,236,108,97,224,76,65,183,66,187,154,197,172,63,90,82,139,60,64,114,141,212,19,152,64,144,67,102,78,97,180,237,11,232,123,176,62,89,196,181,73,109,0,203,185,146,162,229,197,65,220,69,55,200,165,66,10,191,137,88,184,86,222,244,58,118,59,175,201,5,93,87,165,88,100,207,100,181,162,88,167,17,66,74,201,21,250,146,247,53,60,77,224,197,218,12,31,86,111,175,251,222,176,24,240,182,53,117,215,230,232,214,34,161,11,97,239,44,251,206,137,211,218,210,7,34,166,74,7,74,242,159,36,190,33,157,121,133,72,154,149,236,14,215,213,35,123,14,237,104,50,209,230,33,164,118,43,78,236,92,71,26,224,65,192,104,212,12,157,129,191,147,195,69,42,59,184,252,180,159,11,92,68,249,67,192,107,9,71,99,31,21,72,42,96,117,167,199,37,213,2,63,28,41,158,251,126,136,242,113,164,241,137,196,85,35,65,96,149,17,241,76,91,184,83,231,241,11,207,233,122,97,51,155,210,17,107,118,132,239,197,109,35,66,80,180,152,22,106,211,53,64,192,147,37,21,21,86,214,112,48,90,112,103,79,128,39,205,234,5,173,249,91,165,84,179,87,11,249,9,212,227,234,245,77,116,4,217,5,106,147,180,156,104,131,12,39,206,189,206,199,130,51,129,29,79,129,144,214,67,196,121,202,52,74,105,218,27,170,7,33,55,128,244,42,96,202,211,93,36,152,23,9,194,170,37,15,21,66,77,129,141,79,238,11,211,216,227,67,24,53,236,10,114,207,221,162,176,61,204,102,157,247,189,255,191,181,39,55,91,102,70,150,215,227,68,86,126,17,156,46,245,211,114,35,48,211,1,125,46,104,242,210,195,219,206,65,59,48,89,30,4,149,139,33,180,182,154,217,9,228,85,163,113,209,69,61,168,131,187,200,188,39,38,15,196,21,144,137,171,108,143,77,232,141,82,212,214,77,150,9,11,56,226,242,197,124,3,0,219,137,138,94,169,68,176,230,89,120,60,138,109,7,247,35,20,218,174,172,233,132,147,180,138,91,65,113,164,26,38,1,5,69,113,63,188,225,233,174,24,225,85,11,141,57,132,123,245,181,194,245,242,161,222,41,73,94,22,50,35,92,251,39,174,22,80,115,238,255,173,118,176,127,67,249,183,106,43,66,247,63,143,42,58,182,255,136,236,199,175,65,173,97,176,35,48,38,131,239,164,142,213,142,203,246,221,42,52,79,126,52,239,220,154,250,138,68,202,17,1,254,80,84,51,178,133,76,226,200,169,51,161,54,175,87,235,33,150,59,163,141,245,249,38,77,77,88,92,255,234,5,18,80,51,247,56,160,80,38,100,200,24,48,57,113,21,146,233,59,196,128,240,69,137,164,179,37,83,70,206,158,58,31,145,4,255,75,46,215,106,34,173,114,251,185,29,213,95,53,105,8,89,82,92,117,46,155,214,183,112,188,251,72,190,159,248,44,22,167,28,167,6,30,105,246,80,143,208,175,49,36,179,49,27,135,241,201,50,197,190,173,45,8,138,162,160,246,184,68,211,230,121,216,153,37,197,210,226,86,221,165,125,168,206,77,176,28,61,50,27,224,94,86,245,19,38,213,25,0,168,235,135,22,146,42,231,23,252,68,0,155,116,59,61,163,167,48,16,51,168,64,82,144,115,129,210,145,119,41,182,56,114,137,47,189,40,244,87,42,175,242,103,75,230,139,62,47,237,38,22,177,23,40,20,159,186,62,107,248,11,254,85,112,41,108,86,33,219,73,117,68,29,126,202,240,251,14,52,23,13,26,239,43,63,192,69,103,3,209,103,32,53,243,209,2,173,51,176,172,53,30,53,95,134,184,28,1,87,184,237,24,161,116,36,171,210,220,14,255,158,154,135,108,14,65,146,138,204,112,234,197,51,3,146,10,224,122,17,32,151,189,59,40,183,167,219,209,81,155,254,187,116,168,26,240,113,43,139,98,38,31,195,215,148,97,82,32,196,143,33,7,121,97,46,220,138,42,116,135,234,128,58,2,48,1,222,245,41,229,158,48,82,58,197,138,36,226,86,6,165,163,241,111,238,228,137,149,120,70,202,183,173,28,2,139,150,219,185,201,76,203,165,178,8,208,154,67,3,178,28,4,255,233,145,75,60,129,175,36,125,182,20,124,107,182,8,81,184,4,54,72,207,54,196,127,1,175,251,210,200,10,186,93,25,203,101,204,249,86,201,21,11,32,107,137,18,196,90,23,43,47,35,40,246,38,0,237,90,127,243,139,156,84,92,32,250,244,83,168,96,180,158,228,64,116,166,81,94,78,95,220,83,43,206,254,254,124,35,35,67,94,8,57,83,98,144,40,146,19,2,225,249,136,76,3,227,180,70,77,52,116,139,72,122,147,187,41,156,131,177,65,152,121,137,87,39,181,218,36,252,78,208,29,167,90,177,251,153,66,138,78,3,75,171,103,230,157,154,73,237,19,101,43,187,93,233,42,183,193,116,37,96,80,78,54,52,126,192,151,101,197,247,182,17,68,189,29,63,169,238,163,126,87,81,43,193,119,111,209,173,251,60,13,26,88,24,71,146,49,136,249,225,132,241,211,197,53,8,224,88,234,34,52,30,149,153,98,91,20,154,238,80,176,199,66,162,75,182,72,12,134,107,80,148,79,202,121,33,183,189,95,254,92,119,189,192,249,161,77,206,221,0,90,228,145,149,53,56,107,197,158,17,207,214,30,163,137,107,78,64,97,147,3,101,200,249,107,199,245,50,5,117,124,3,68,154,56,225,54,237,143,68,241,113,42,119,233,198,226,201,14,39,206,211,235,168,204,63,94,186,102,147,80,83,14,165,151,130,63,54,40,92,230,236,239,242,79,227,83,58,59,192,139,244,181,102,27,31,20,3,244,140,162,43,72,153,149,112,60,11,251,59,88,100,107,234,47,204,209,62,99,253,64,168,147,107,162,29,27,24,161,71,63,177,154,103,145,149,77,219,160,26,72,106,27,169,212,82,253,196,46,188,224,157,41,168,26,10,74,224,128,18,34,37,148,114,38,127,6,159,139,161,198,54,66,185,80,132,43,222,186,148,61,178,44,61,42,219,193,221,205,115,16,124,248,242,194,80,72,149,185,32,211,108,183,164,74,40,41,82,5,89,48,161,140,183,13,4,14,167,134,253,135,44,139,1,221,55,46,239,45,70,231,5,175,145,254,194,27,215,29,38,175,195,103,175,50,186,31,101,191,47,88,132,179,122,54,56,55,51,213,42,220,117,97,10,65,234,133,58,21,89,84,53,47,33,173,54,34,192,53,156,188,232,216,80,40,194,95,210,51,247,144,214,36,90,246,106,53,29,252,143,1,150,46,101,67,107,189,158,171,196,141,141,195,112,132,92,180,96,166,56,56,249,84,184,131,217,120,126,244,155,25,83,129,232,64,80,108,79,0,124,159,159,37,149,26,155,173,83,25,76,47,64,185,77,235,30,179,238,210,33,213,42,83,239,206,177,65,140,12,109,95,112,69,218,55,251,17,35,246,171,20,53,120,183,217,149,103,235,205,23,157,55,185,197,130,137,208,101,88,20,244,241,95,165,146,89,217,251,114,185,194,173,41,195,118,141,34,80,169,184,94,35,116,166,255,150,91,212,219,204,50,184,218,1,111,174,216,6,117,247,17,209,174,91,49,242,160,4,92,172,22,187,142,45,154,177,245,54,228,254,71,94,10,45,128,80,168,109,154,195,134,91,249,50,175,240,189,199,234,30,121,234,204,134,1,119,71,229,40,137,193,94,112,114,35,137,126,103,5,163,195,81,111,120,18,30,33,185,81,59,225,244,41,226,242,195,248,71,92,186,72,230,172,228,233,181,23,227,239,124,120,212,54,46,255,135,15,232,145,22,133,169,161,39,34,17,232,16,35,158,51,130,165,189,113,201,236,0,65,40,197,198,187,152,95,127,59,116,246,115,46,8,135,140,12,78,104,132,10,142,155,6,195,96,54,101,105,141,155,239,40,89,239,49,193,145,189,216,197,57,230,229,130,233,156,135,33,227,155,64,109,225,165,136,96,3,76,229,182,81,71,246,9,151,223,131,11,61,107,122,160,216,176,144,32,16,26,217,166,108,53,91,53,207,3,245,231,44,18,118,4,192,70,167,28,194,114,34,192,86,109,252,177,177,74,217,26,195,153,3,198,170,137,154,77,243,160,247,207,175,170,148,229,6,216,199,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,51,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,230,255,255,159,249,14,13,27,63,145,42,163,163,104,186,234,137,6,221,216,118,235,216,71,195,187,245,32,85,8,208,21,0,0,0,3,113,95,52,0,0,0,16,255,255,255,15,108,10,30,188,110,143,70,134,183,23,204,215,162,167,126,126,73,186,175,71,214,95,206,30,141,177,155,47,161,213,145,45,92,48,72,179,58,249,54,150,41,180,3,66,188,21,78,218,34,30,204,61,218,34,222,82,176,5,98,2,152,14,33,126,44,184,181,22,94,220,17,255,186,193,23,160,223,16,168,179,20,185,170,86,175,173,76,204,65,204,189,31,86,98,104,119,237,253,24,80,61,220,221,45,57,88,46,148,125,250,151,211,182,147,170,251,157,124,145,86,251,174,149,16,212,217,146,93,102,184,79,7,90,168,67,179,167,43,177,190,157,93,83,187,54,124,24,158,72,47,130,153,101,68,40,10,228,12,247,8,173,124,146,164,217,56,113,197,19,119,162,80,33,16,147,209,75,38,55,142,176,170,149,99,109,240,9,44,135,4,227,58,211,71,155,217,4,183,158,58,51,145,78,160,19,208,143,111,121,11,75,56,174,237,80,138,61,109,113,47,187,251,208,29,146,158,230,158,159,71,118,58,148,67,192,249,224,29,140,49,42,233,77,16,135,43,233,153,217,236,6,8,3,0,0,208,187,224,165,203,179,81,44,109,217,184,155,120,23,9,132,132,35,209,240,40,125,224,148,163,88,235,44,49,96,42,110,194,55,197,153,144,86,119,130,227,30,52,48,230,160,66,51,167,147,39,132,122,79,125,83,142,194,72,2,46,105,241,222,113,103,61,44,45,51,148,167,122,141,38,28,136,125,71,217,205,161,140,165,97,122,242,228,20,49,130,166,16,171,157,151,120,166,247,200,243,83,148,219,75,15,144,5,148,223,93,233,173,255,177,165,188,139,35,160,138,119,159,206,31,45,38,109,146,45,61,146,60,55,200,117,198,160,188,130,105,191,250,45,198,127,201,55,26,225,112,175,71,13,10,60,38,29,243,8,231,230,120,79,159,183,55,72,180,52,113,145,215,59,72,238,175,106,31,25,42,121,245,155,125,5,94,90,4,123,251,28,165,84,163,40,174,29,42,212,184,93,63,25,176,166,224,114,147,243,127,85,56,165,82,18,56,168,47,87,49,70,4,47,210,1,87,251,164,241,40,67,63,180,164,115,46,124,58,245,79,140,92,2,168,162,116,72,71,153,97,93,40,0,0,0,7,113,95,52,95,102,102,116,0,0,0,68,198,179,43,33,83,197,251,207,15,77,146,188,13,76,232,96,219,35,7,81,33,67,55,95,158,5,176,72,105,23,227,47,182,113,139,138,225,69,248,201,102,143,58,18,211,140,168,161,147,201,205,246,29,4,182,60,150,57,168,138,31,195,241,36,117,63,215,6,143,250,157,229,216,187,181,228,169,142,235,226,184,151,47,251,232,132,65,227,202,153,187,161,161,179,220,73,245,150,202,56,74,127,47,176,214,106,16,22,94,229,87,163,254,232,30,78,51,110,140,161,146,205,241,96,213,49,45,91,123,35,120,164,91,89,123,46,54,138,2,149,215,6,115,45,223,6,180,204,162,16,248,42,163,38,63,209,0,95,86,91,50,116,113,61,219,8,108,93,185,93,61,67,99,169,157,2,224,28,173,4,88,59,205,8,241,59,217,227,96,218,47,37,152,116,94,65,117,64,164,236,28,209,130,160,61,167,216,55,77,97,209,28,123,214,101,243,242,131,69,156,125,212,96,74,154,213,178,183,32,158,162,188,16,107,182,143,144,230,83,227,100,248,18,55,208,198,153,25,92,95,135,9,122,48,106,83,78,199,221,43,249,7,57,80,165,113,150,116,225,86,141,123,158,220,158,149,138,171,5,133,128,112,71,36,225,105,11,95,108,83,182,197,162,0,145,113,203,168,101,228,230,85,107,42,138,125,239,117,88,88,89,43,225,167,95,30,170,192,195,14,106,224,112,70,120,96,247,91,247,43,173,31,194,36,23,254,199,58,185,43,41,228,41,69,148,96,126,205,113,245,75,67,226,69,20,1,115,70,15,142,32,48,160,218,137,78,247,42,66,58,29,174,137,216,140,201,174,154,192,2,186,0,106,7,136,167,183,0,218,208,136,223,254,123,140,162,121,137,115,205,175,105,75,91,195,117,184,106,141,197,146,204,208,47,57,85,0,215,71,80,146,21,57,128,99,16,215,203,202,56,209,101,160,89,156,159,239,89,216,231,206,0,90,238,169,126,209,57,151,233,250,74,66,25,158,92,31,8,61,179,49,53,42,36,247,204,27,253,146,235,155,219,96,104,163,67,215,13,61,64,162,154,70,127,111,13,205,236,66,80,52,199,182,197,46,192,167,130,189,197,198,181,253,6,209,88,156,167,22,5,170,32,106,171,200,211,102,38,109,119,19,209,68,116,123,245,21,193,59,228,137,42,223,27,152,108,128,206,111,129,4,62,181,32,233,46,103,253,8,142,92,217,27,255,9,54,113,143,229,65,100,168,84,191,47,68,216,221,206,214,192,157,165,93,129,33,153,161,21,215,17,22,84,145,121,183,156,79,157,198,126,97,161,74,47,232,153,170,228,153,100,44,30,46,122,22,9,1,158,146,53,116,174,141,229,175,12,17,70,72,43,2,10,88,190,239,82,97,8,127,159,57,89,126,180,104,52,143,0,79,187,95,253,137,86,229,36,225,223,197,67,9,53,20,186,142,225,79,59,53,53,1,87,58,149,214,167,224,177,172,171,89,243,41,222,238,67,95,175,80,6,78,78,135,44,15,181,170,84,40,128,212,102,21,51,191,194,41,7,40,71,18,129,39,88,92,147,146,233,141,250,204,212,180,92,165,13,14,41,99,59,182,75,56,44,122,39,167,207,186,65,226,94,243,171,26,214,21,107,79,103,100,154,118,130,195,93,18,172,29,26,32,203,182,204,44,241,6,179,165,210,226,121,120,5,1,115,45,214,32,24,247,165,100,166,187,45,165,70,105,122,43,22,231,127,162,128,110,169,137,115,160,37,41,104,253,222,75,148,63,169,119,14,212,66,50,31,232,63,243,204,76,91,210,120,251,220,197,14,139,97,94,165,169,178,130,169,225,100,86,86,96,224,105,29,167,50,201,20,29,147,221,157,118,159,211,11,125,82,145,43,24,100,190,243,176,93,249,175,203,213,1,129,31,89,60,158,55,247,28,154,123,189,46,30,27,11,80,208,101,29,235,238,84,198,142,42,7,148,36,154,90,219,123,6,23,201,38,26,47,211,38,244,119,169,250,106,212,8,177,97,42,205,255,91,22,150,71,23,113,31,141,240,125,244,108,55,61,237,85,143,222,162,246,159,123,223,23,129,160,211,125,227,136,203,32,3,75,22,218,90,206,73,25,35,28,24,145,19,93,232,96,90,5,206,123,247,34,71,213,120,117,165,236,30,128,171,17,58,59,86,33,144,21,119,239,217,137,21,115,13,42,1,209,142,6,149,159,115,126,37,112,76,60,244,46,164,32,237,247,236,13,190,178,92,103,87,210,236,44,75,140,34,43,164,167,46,68,150,70,48,180,124,222,157,154,98,127,135,153,14,9,248,187,15,194,15,173,15,56,180,90,114,40,97,92,80,130,12,56,63,243,190,48,158,125,213,121,23,139,233,39,63,91,54,254,238,150,11,151,56,7,17,166,94,149,234,91,165,220,218,33,126,188,27,180,50,82,45,56,176,196,70,117,228,214,32,162,174,120,141,13,233,235,177,182,150,187,41,14,193,3,0,203,168,225,129,240,113,177,7,12,249,44,233,227,25,234,124,118,72,45,103,54,108,81,166,194,91,130,201,92,91,187,63,30,216,123,95,44,172,147,128,190,36,253,57,141,247,122,70,71,39,232,132,7,195,10,67,100,178,5,28,75,190,108,104,225,139,204,237,77,198,7,179,209,211,61,23,167,87,98,75,148,240,202,238,160,72,20,53,58,79,250,253,75,134,23,247,196,77,243,34,118,24,243,250,48,145,59,246,19,118,76,221,174,198,239,218,120,152,100,253,133,62,44,176,16,16,39,52,51,180,174,140,65,161,150,153,250,161,209,207,242,235,52,217,78,39,24,205,134,14,134,84,75,158,236,4,54,102,225,203,210,5,224,77,33,146,219,227,171,207,139,21,217,237,195,48,41,167,176,105,152,29,58,22,223,215,50,75,21,46,132,60,144,222,35,35,19,32,80,140,65,255,93,250,174,131,68,37,104,19,82,136,31,243,101,28,54,13,72,175,55,232,49,96,79,156,230,241,248,155,241,237,40,225,203,67,203,38,123,64,217,140,57,160,172,143,208,243,79,212,41,12,17,104,188,153,35,124,244,135,44,135,75,175,217,145,198,141,41,60,35,50,129,236,47,236,63,87,105,6,226,204,30,87,46,234,7,45,75,28,108,8,15,224,164,36,162,13,144,127,33,3,168,126,39,253,120,225,110,55,35,198,22,61,182,122,17,134,117,70,69,208,31,157,205,66,18,112,50,237,237,101,114,155,220,220,172,158,14,135,213,116,83,85,193,252,18,138,84,255,177,209,66,111,24,92,159,250,125,85,112,86,116,33,191,144,86,53,172,202,36,150,155,158,190,212,200,77,200,144,67,126,32,18,135,68,52,50,128,121,127,78,103,21,58,92,141,243,227,59,29,229,73,13,197,86,76,96,158,113,218,167,14,116,98,146,160,22,158,46,74,53,91,96,189,42,98,212,100,34,128,251,189,108,135,224,134,187,10,66,162,249,70,122,91,157,26,210,90,231,76,3,175,107,195,129,45,154,8,230,227,172,170,215,210,102,236,172,5,132,58,141,245,254,97,111,33,143,64,232,165,49,25,32,193,149,67,161,226,6,42,228,31,205,168,99,231,43,97,122,223,218,220,117,61,106,134,56,73,210,247,223,247,163,38,121,228,171,101,154,228,24,205,61,250,149,35,91,64,171,243,51,184,138,103,189,115,145,154,143,59,247,140,148,166,93,123,198,125,254,246,234,180,71,202,182,6,204,198,50,32,59,208,80,2,139,193,229,79,78,54,76,57,25,69,174,86,92,125,184,176,195,151,253,143,186,88,93,183,45,186,204,206,188,137,82,231,53,58,148,235,137,111,161,93,224,38,12,102,103,92,63,211,101,146,0,139,129,45,39,86,26,207,101,43,190,62,150,49,221,94,16,211,194,194,138,50,10,189,157,35,254,171,106,121,50,20,64,171,18,239,173,167,224,11,199,167,123,121,148,242,102,156,73,214,115,139,238,19,138,101,231,112,158,26,97,72,64,87,59,28,39,3,28,51,20,0,83,166,161,105,158,193,57,23,100,108,197,105,112,4,79,93,98,163,102,187,89,181,89,115,90,223,226,16,144,155,119,46,112,213,149,74,80,41,146,136,99,149,43,96,30,61,26,205,0,240,188,198,201,155,193,217,203,230,193,28,210,125,247,190,249,41,82,109,115,239,198,111,239,245,26,215,83,14,173,238,8,120,232,137,102,76,43,221,196,68,212,58,159,214,251,64,182,125,7,82,119,172,26,18,80,86,85,37,134,48,213,197,88,17,181,171,198,245,108,33,175,241,39,59,239,36,53,93,57,34,231,194,37,35,185,60,19,118,176,160,39,29,103,35,71,255,199,120,236,181,79,4,149,62,214,225,226,80,154,244,105,84,90,180,34,171,16,241,159,228,242,1,216,49,140,172,68,187,176,50,52,30,245,208,233,224,88,209,1,38,226,248,249,28,129,21,59,60,38,123,136,25,128,119,90,30,207,81,243,80,41,113,145,48,17,195,128,78,48,6,41,6,164,187,69,52,86,155,3,136,169,225,161,64,190,100,161,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,52,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,225,255,255,239,21,67,163,199,104,94,139,66,57,223,182,33,184,76,86,81,230,142,71,174,242,154,253,186,22,128,218,35,0,0,0,3,113,95,109,0,0,0,16,255,255,255,15,108,10,30,188,110,143,70,134,183,23,204,215,162,167,126,126,73,186,175,71,214,95,206,30,141,177,155,31,171,122,171,39,137,98,22,245,110,230,148,101,145,202,169,222,116,161,116,24,73,104,187,20,203,121,75,71,184,15,202,19,196,215,90,106,7,244,200,3,101,79,216,127,244,74,89,69,37,88,241,29,46,116,28,57,157,199,12,162,181,76,74,5,197,38,34,182,73,236,14,137,58,110,9,126,222,74,160,1,156,39,57,216,86,29,84,40,106,205,71,86,181,98,69,4,235,108,201,30,199,209,137,71,190,68,91,83,28,126,140,7,44,7,43,223,209,131,92,7,206,183,242,173,165,112,120,21,203,166,195,75,235,217,228,177,74,18,143,32,156,78,120,248,230,27,108,85,90,18,59,138,108,42,165,60,174,164,185,29,23,214,37,215,23,220,138,27,116,129,76,113,87,12,39,132,220,78,3,126,111,79,223,58,7,77,166,7,25,100,26,32,34,72,239,2,205,165,79,231,206,214,127,105,66,243,205,48,66,253,5,206,169,85,95,31,138,42,240,197,164,19,161,34,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,32,162,41,83,37,244,221,231,151,146,201,77,37,176,63,241,6,159,25,38,52,159,225,61,44,105,61,227,8,3,122,153,50,61,40,165,133,140,1,25,64,44,33,225,249,83,157,218,226,55,0,144,99,136,209,51,127,140,216,36,63,189,1,26,43,135,125,220,166,159,94,13,192,53,209,31,147,26,215,198,187,26,59,224,242,218,230,84,96,160,73,181,24,147,216,185,17,23,147,54,193,96,25,58,64,100,156,23,160,116,82,219,72,142,169,215,35,155,7,68,105,133,136,112,20,64,44,80,11,235,180,61,55,83,198,194,140,103,143,186,193,251,95,136,154,28,50,125,226,224,116,188,93,220,254,192,22,239,188,15,45,234,41,218,24,124,25,87,40,29,239,108,8,241,219,12,164,128,9,126,3,71,246,112,125,34,83,139,217,89,234,73,16,148,19,18,128,113,250,87,87,227,202,201,120,85,187,50,98,193,80,227,105,145,49,152,200,190,254,117,141,248,77,40,40,0,0,0,7,113,95,109,95,102,102,116,0,0,0,68,94,214,202,65,150,190,86,65,72,163,37,61,92,110,171,24,182,226,190,94,164,100,10,21,229,152,195,63,112,255,243,92,105,117,149,195,154,41,36,68,158,199,100,51,168,131,47,103,109,108,210,48,225,32,189,106,220,54,140,118,108,252,14,23,216,153,239,166,150,3,5,124,157,54,52,94,31,77,17,87,57,23,20,208,127,120,44,179,7,33,91,205,131,8,37,46,197,19,106,152,169,172,25,136,192,17,241,32,43,213,220,105,86,78,152,83,253,86,97,177,14,220,92,51,44,194,166,20,117,72,213,68,204,10,179,107,11,116,182,225,149,139,161,83,128,187,221,192,128,177,219,11,19,166,88,72,88,22,165,49,236,43,49,108,221,132,184,156,250,154,54,116,59,21,86,127,132,143,15,156,4,244,107,12,140,73,150,110,57,236,16,70,0,115,160,156,64,10,203,33,84,176,94,231,125,169,44,167,212,115,98,212,79,199,81,52,245,107,222,9,189,160,212,28,118,59,177,169,56,199,47,26,160,44,230,125,53,133,212,72,153,208,216,112,78,234,76,38,19,250,149,255,103,59,182,1,170,36,89,207,121,219,120,148,8,255,119,142,203,246,254,240,233,140,57,50,0,202,32,116,154,149,145,132,41,45,214,19,164,119,80,90,241,229,57,182,169,16,246,230,132,187,27,236,104,104,162,158,230,181,148,59,53,175,94,184,30,175,116,60,254,180,166,72,94,233,196,37,24,254,62,131,180,25,158,72,224,201,239,189,178,168,175,194,93,84,92,184,35,183,145,8,226,101,31,126,123,46,120,78,81,133,114,63,20,35,12,128,212,170,109,44,146,231,149,203,231,96,70,219,69,41,115,87,65,151,212,119,169,174,252,226,59,90,40,88,184,108,112,240,115,119,151,180,203,206,102,191,198,99,14,71,229,188,135,85,182,212,93,52,139,174,11,66,2,10,149,144,47,181,62,141,108,85,194,146,182,176,91,151,3,223,225,238,21,83,6,76,91,33,248,136,248,26,230,114,9,238,124,251,103,152,55,231,233,41,36,155,217,168,38,110,91,153,188,234,80,98,71,19,74,111,254,219,181,217,64,76,201,43,1,99,6,135,21,123,128,53,32,157,134,26,72,213,38,234,19,27,229,251,214,84,89,232,109,165,193,143,249,52,194,41,6,52,35,190,212,201,80,142,104,134,140,118,169,106,129,118,150,23,73,136,115,53,109,19,38,129,3,101,156,180,144,228,45,154,126,21,207,25,181,143,127,38,161,37,194,89,179,133,74,46,163,253,146,95,217,244,223,217,181,244,163,180,212,193,178,244,184,180,21,175,252,45,191,24,69,39,82,180,0,49,249,228,94,94,146,53,2,30,8,56,105,58,96,182,107,72,131,124,218,53,138,169,242,214,49,99,14,211,191,118,158,66,204,74,208,213,181,79,128,223,247,74,203,130,110,248,133,79,59,107,168,243,22,156,103,53,194,35,29,111,200,216,156,91,21,50,60,194,248,15,255,109,174,36,132,110,69,76,180,34,171,110,15,144,122,56,160,128,36,190,218,117,183,116,22,232,102,23,63,119,25,49,228,240,103,221,97,49,177,152,99,37,181,31,147,75,80,130,78,224,9,122,244,83,0,251,26,253,161,153,126,109,33,71,129,207,78,163,91,154,62,159,15,213,236,255,77,203,3,222,51,178,211,29,199,26,126,170,37,199,75,2,71,41,237,9,215,73,82,30,180,87,242,80,210,25,111,3,250,186,167,186,73,82,190,155,161,237,112,31,42,3,236,167,152,197,44,38,205,5,201,100,144,143,35,88,247,232,176,150,26,2,118,125,221,118,41,141,31,208,9,31,235,64,255,1,136,208,215,70,236,28,77,35,253,178,65,163,125,135,126,108,254,213,56,103,225,70,62,172,113,14,244,72,60,226,233,204,92,112,175,42,144,143,211,130,126,176,196,183,227,101,12,70,55,85,220,139,136,130,226,0,19,83,16,89,127,103,11,246,37,8,128,78,58,211,175,163,24,184,254,177,154,185,163,104,38,92,84,93,41,80,20,4,236,106,198,132,106,91,165,205,152,17,23,91,126,125,173,155,20,13,42,196,155,220,209,60,128,239,142,140,228,222,28,105,187,19,94,179,158,244,115,41,210,106,67,53,5,36,65,68,182,240,176,102,107,227,194,239,250,34,244,35,72,147,179,74,106,114,90,11,85,244,35,218,203,97,149,75,44,209,246,13,251,129,151,118,45,184,64,90,138,68,212,57,2,4,81,95,180,117,20,127,52,180,187,21,107,112,161,68,86,108,153,118,236,71,82,19,141,113,144,66,182,145,20,65,73,14,104,221,26,24,98,23,18,140,237,151,37,243,154,10,47,32,13,194,202,210,233,174,54,15,213,187,239,162,85,28,111,91,194,195,181,77,63,247,97,10,150,133,63,20,60,88,28,237,158,64,144,102,174,222,12,21,213,45,114,185,243,132,25,151,176,229,230,184,205,159,156,45,215,145,247,248,2,72,203,174,47,69,0,1,88,255,32,63,213,174,7,140,13,195,140,245,33,193,206,228,95,229,221,111,252,225,255,163,44,49,115,134,156,154,103,54,180,148,37,156,62,162,72,208,231,221,159,54,120,161,2,101,143,17,134,117,11,110,247,121,237,44,170,35,234,187,250,52,224,16,249,130,14,158,246,159,47,175,102,183,20,62,139,209,135,218,51,134,123,76,248,179,57,76,32,51,105,150,142,252,204,198,24,235,48,2,53,124,4,135,89,221,79,225,41,251,64,44,226,212,157,111,144,252,22,36,116,195,128,112,252,221,204,29,101,248,223,176,153,244,102,2,102,213,138,221,88,191,250,124,128,70,47,193,57,157,91,11,164,238,237,184,67,187,128,73,228,3,66,195,248,23,211,73,232,69,19,47,88,248,202,146,168,11,158,198,0,111,50,30,178,20,36,68,28,194,48,228,6,227,178,254,244,153,32,91,208,154,159,55,84,134,233,118,169,177,164,116,216,136,175,20,116,246,53,218,101,143,117,247,192,124,85,223,88,53,175,0,104,109,171,122,213,162,4,69,234,37,127,122,135,246,122,93,12,71,176,117,88,253,136,177,82,55,16,33,187,177,66,39,167,232,209,185,135,108,154,82,174,152,183,163,241,118,143,41,225,6,41,203,1,40,106,118,59,20,35,31,110,22,57,127,72,254,133,84,48,11,60,223,83,111,249,110,5,205,248,23,72,227,66,60,154,64,132,208,64,148,151,179,179,58,244,145,90,31,130,228,196,136,250,250,9,34,103,195,151,98,103,92,117,148,174,60,137,60,6,82,93,182,182,88,87,168,110,236,61,1,165,61,188,122,35,70,217,231,64,138,93,201,163,47,22,219,4,2,40,177,229,153,27,118,0,113,214,255,210,225,248,238,201,119,67,62,29,150,252,203,129,48,221,243,247,75,25,120,118,21,47,192,236,41,221,21,110,69,248,3,213,65,151,22,170,47,55,75,75,104,13,243,124,213,39,75,109,47,193,101,23,232,17,86,164,216,58,134,113,31,79,65,226,147,26,208,156,190,91,16,187,133,103,158,17,31,49,3,169,37,29,51,187,203,72,226,141,131,208,139,82,114,247,115,187,251,89,206,58,122,236,159,250,247,44,254,174,135,61,187,40,46,132,204,72,28,199,239,38,64,37,211,238,159,248,205,55,104,64,96,56,46,119,43,215,44,15,96,89,11,180,166,51,63,98,156,115,81,83,128,251,93,42,91,214,127,75,183,61,15,135,85,124,73,215,32,255,240,197,251,37,174,117,184,90,75,155,78,53,63,208,168,105,66,64,240,130,253,100,202,162,164,238,155,183,156,10,16,211,118,45,0,204,139,43,188,65,68,22,9,174,248,96,240,111,155,186,134,61,2,88,182,135,203,65,178,126,213,136,3,194,223,79,1,24,110,219,146,156,7,29,211,232,50,248,167,87,130,38,25,164,10,6,10,143,77,36,170,129,147,176,107,52,10,201,157,48,51,17,220,67,7,191,195,45,70,162,166,8,40,175,38,157,5,248,37,58,145,114,102,229,84,95,28,118,152,127,204,33,117,5,15,17,36,111,219,149,132,66,218,73,138,231,98,186,201,139,195,234,102,111,66,86,96,62,92,29,13,176,63,163,60,134,253,48,73,248,105,28,117,163,245,226,55,7,88,9,160,137,62,34,133,9,197,143,151,229,237,15,172,39,140,111,23,226,229,52,85,210,78,208,146,69,20,226,71,106,78,147,16,179,77,76,39,36,35,149,127,70,161,70,17,23,5,130,63,97,249,54,21,198,127,101,221,154,169,113,236,124,31,219,155,39,85,255,215,241,39,2,208,162,80,13,4,107,29,193,236,46,18,225,80,246,65,255,80,198,167,139,88,161,47,72,55,189,6,144,250,120,82,35,68,224,183,204,117,130,74,176,201,172,29,155,34,199,164,136,68,228,148,145,133,72,215,29,141,251,206,214,61,81,252,18,3,112,86,228,213,20,163,168,128,95,165,22,62,124,10,62,136,100,171,58,37,161,79,205,51,225,245,73,199,74,173,34,112,124,197,137,199,189,89,114,188,236,44,235,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,109,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,3,113,95,99,0,0,0,16,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,16,179,110,244,26,187,222,193,109,106,79,94,71,173,135,192,1,211,58,27,45,81,71,158,234,164,50,97,40,82,26,125,7,136,175,181,212,14,232,145,7,202,158,176,255,232,149,178,138,74,176,226,59,92,232,56,114,58,143,25,68,107,153,148,10,84,170,181,9,44,52,46,34,174,88,80,143,85,245,96,248,28,248,24,152,148,115,192,26,63,86,61,55,235,26,25,41,242,157,219,105,47,225,91,218,126,216,60,226,18,84,8,5,200,4,114,63,225,87,232,4,52,37,247,115,110,160,165,35,21,208,20,113,227,155,171,240,137,126,178,63,220,71,75,97,140,211,117,31,169,225,250,165,147,65,224,81,179,137,61,27,45,172,75,190,155,194,51,243,86,146,223,104,102,48,26,224,91,69,133,122,40,89,110,189,228,249,26,46,191,121,208,15,108,44,215,248,26,184,67,196,14,65,25,124,255,194,60,202,213,243,173,172,90,210,47,194,222,28,71,28,2,166,28,44,2,0,0,224,39,235,195,135,34,225,114,243,144,208,103,80,186,176,2,3,109,139,160,112,83,64,99,194,229,156,200,0,243,138,232,241,138,183,125,35,164,73,181,137,108,170,224,69,62,103,61,71,94,12,161,145,132,219,152,220,211,74,41,38,121,80,74,27,133,13,80,60,199,209,8,122,95,82,129,157,18,168,158,69,90,93,23,70,239,16,24,157,7,181,207,37,112,19,112,15,227,138,29,66,133,112,188,112,47,101,151,149,30,81,94,96,197,187,78,200,213,173,49,168,67,166,10,30,15,98,36,134,100,20,134,105,18,152,124,151,53,148,43,35,149,83,15,66,213,237,103,179,245,122,58,109,4,174,190,12,40,114,197,101,161,154,234,238,211,40,250,57,231,69,240,56,149,59,148,105,179,52,70,47,129,90,226,175,144,3,3,14,212,83,180,49,248,50,174,80,58,222,217,16,226,183,25,72,1,19,252,6,142,236,225,250,68,166,22,179,179,212,147,32,239,217,75,234,50,167,94,238,115,150,140,44,47,243,85,22,118,194,122,96,172,31,225,121,33,117,240,191,74,67,161,22,0,0,0,7,113,95,99,95,102,102,116,0,0,0,68,194,82,223,29,102,119,10,75,32,27,76,125,128,89,128,28,254,131,181,64,250,230,178,103,145,114,105,114,250,227,26,21,93,102,220,126,14,29,198,105,253,25,22,198,116,84,0,34,68,154,200,240,59,173,44,168,80,180,101,69,243,176,57,51,241,220,191,129,58,243,19,219,172,24,49,61,248,20,98,150,124,118,9,203,195,86,74,166,149,144,105,192,38,213,187,67,99,185,133,191,68,246,197,81,247,241,16,186,139,65,102,134,71,2,169,212,163,152,239,56,7,255,6,201,55,35,128,16,168,83,191,170,23,117,199,20,215,22,143,255,73,18,32,240,224,146,40,227,124,97,25,52,233,126,189,4,37,13,165,11,171,145,187,8,39,197,70,136,233,9,172,108,190,109,21,168,245,149,117,214,16,150,108,82,210,54,176,17,203,22,143,36,43,34,68,127,21,199,186,167,239,32,12,38,230,158,130,248,157,204,39,116,253,14,179,218,174,42,2,172,69,164,133,69,109,43,123,253,115,69,133,72,147,62,76,171,9,155,116,9,154,178,230,73,6,233,120,33,27,247,115,102,204,196,187,2,25,148,101,22,97,194,93,207,194,230,208,4,181,3,41,249,10,53,111,172,155,229,154,57,194,195,199,72,75,69,143,90,91,15,204,7,122,151,55,89,231,245,94,26,147,169,82,230,18,123,24,154,43,60,7,187,43,149,158,245,205,12,43,67,82,91,161,120,98,161,167,88,111,105,155,105,226,32,32,217,77,6,66,96,39,163,208,149,59,102,13,183,175,191,126,67,60,222,226,133,5,47,132,196,218,54,109,195,51,25,177,37,176,58,113,27,130,9,175,30,115,118,0,243,218,198,251,72,168,253,84,143,231,249,1,123,24,235,96,203,110,81,213,57,43,165,47,209,162,74,19,204,129,60,28,93,218,104,139,81,180,138,152,86,158,59,172,207,128,194,35,86,236,199,134,95,210,23,172,224,16,142,126,86,183,154,108,68,67,27,153,52,179,56,78,172,221,86,110,219,47,71,113,13,166,164,19,237,124,152,62,219,141,128,236,193,59,15,91,178,50,168,82,72,62,255,95,232,233,190,25,255,175,39,255,6,41,159,129,203,122,201,6,216,182,204,153,60,129,192,107,205,43,241,188,66,114,121,170,18,105,128,116,197,74,141,183,13,221,190,59,104,36,216,170,28,17,109,200,152,185,83,69,181,163,13,242,50,70,215,90,64,44,110,250,203,248,99,216,166,163,186,23,196,6,90,126,201,61,244,86,106,24,222,87,152,39,18,159,47,52,12,199,190,185,251,176,86,239,242,169,17,228,68,242,30,29,8,22,226,46,20,77,72,71,250,139,83,253,3,203,35,14,48,46,70,171,247,81,207,59,142,140,166,41,4,144,84,38,185,163,90,83,183,205,24,17,190,56,42,142,251,208,75,188,148,62,62,127,132,215,175,121,207,198,39,55,160,79,140,22,64,65,6,151,137,136,49,74,110,105,76,134,229,87,22,207,3,225,231,36,15,138,65,9,45,195,127,200,253,11,143,133,165,127,238,203,5,255,227,225,39,20,165,234,233,235,4,137,236,168,101,211,55,248,242,189,236,44,134,79,78,189,233,54,1,230,140,32,66,228,17,209,210,25,147,103,220,175,83,102,17,45,174,196,74,104,179,134,77,205,157,233,29,165,248,121,116,186,72,146,141,171,194,171,27,167,216,164,57,158,93,167,48,131,117,22,40,94,145,132,208,119,176,37,194,181,29,135,135,6,129,2,150,248,122,83,108,108,214,245,220,52,82,70,95,18,150,96,6,234,25,110,26,36,155,217,6,131,6,81,33,27,14,181,42,232,242,0,5,243,240,172,132,160,24,7,27,24,56,148,147,207,141,59,200,178,151,58,142,210,81,94,38,152,227,129,160,27,117,51,98,206,178,141,18,62,14,241,254,242,93,60,3,31,129,170,74,46,178,46,92,4,166,210,199,108,186,151,170,254,252,186,72,251,163,255,237,39,54,67,32,191,12,254,209,40,93,35,195,126,243,117,129,244,160,73,250,223,234,29,140,95,152,72,117,112,156,188,48,234,54,193,57,3,146,33,5,98,203,191,6,57,173,12,39,62,100,247,8,66,154,222,145,58,149,115,72,139,112,54,73,7,55,225,93,14,233,16,146,12,41,2,73,168,63,203,64,236,106,6,215,60,12,59,125,250,137,157,225,254,150,217,245,115,52,167,96,213,139,239,254,135,17,204,244,89,159,163,42,185,35,235,87,240,183,34,1,114,29,239,124,216,85,84,96,88,57,32,229,163,110,54,101,6,61,158,155,157,95,179,89,116,10,20,32,215,22,190,222,16,227,17,227,84,18,240,205,71,70,175,188,9,110,63,200,22,46,8,165,44,212,114,243,213,164,223,136,181,94,47,232,212,176,78,233,18,158,177,24,78,48,97,184,64,148,99,160,0,93,80,250,178,158,161,17,103,101,79,42,155,60,227,200,145,179,169,46,68,203,200,245,23,93,155,178,198,199,160,94,12,78,66,152,170,121,174,189,10,49,46,181,110,45,60,192,34,121,185,203,95,255,248,115,162,8,146,50,110,107,218,179,97,199,87,57,151,50,52,140,249,219,100,80,252,132,52,254,37,184,229,38,113,241,29,216,209,65,247,60,132,149,146,191,25,49,176,75,144,175,157,86,219,24,87,117,105,19,97,48,40,75,167,135,100,2,72,228,51,11,159,128,104,58,161,231,237,237,201,44,72,104,135,196,67,100,198,212,63,181,160,242,13,248,86,188,4,39,247,60,1,25,185,69,30,224,56,203,37,92,118,3,86,65,97,74,182,169,50,162,137,125,111,168,126,224,152,21,189,40,60,206,212,16,57,104,141,222,191,78,149,143,172,17,79,185,122,50,239,70,162,155,101,233,137,136,129,135,132,246,172,115,121,40,162,89,57,10,227,0,100,142,209,113,215,173,123,85,94,93,15,198,160,167,23,5,168,16,112,187,87,34,93,123,216,10,106,77,188,54,20,215,120,133,79,195,78,195,142,222,25,175,198,18,29,231,67,29,65,42,244,35,156,188,95,63,171,50,149,27,160,5,96,236,91,4,180,107,246,254,40,63,46,98,62,209,161,91,58,13,201,169,133,20,78,54,217,130,173,59,136,5,28,206,60,255,173,74,165,191,32,177,165,93,195,153,211,19,162,83,59,18,133,149,192,210,221,187,37,105,211,219,238,6,32,189,56,111,196,19,51,117,208,124,53,105,69,188,234,112,38,219,93,154,205,3,162,77,112,122,136,85,119,201,227,4,233,25,134,154,112,179,180,106,202,166,195,245,212,16,15,50,64,245,8,151,74,107,239,238,212,129,156,216,53,161,133,3,104,177,180,115,250,213,199,172,150,43,30,178,102,100,35,64,161,111,114,19,6,184,74,58,82,247,202,0,129,61,24,84,236,249,216,126,15,239,22,215,7,127,174,194,104,120,140,34,191,51,185,46,176,226,11,255,24,139,61,250,252,101,20,35,242,18,193,115,129,244,71,0,250,130,53,136,175,237,22,87,3,249,14,103,249,47,172,233,63,133,148,237,205,151,202,95,34,203,82,211,147,113,96,156,3,36,50,128,243,37,111,122,182,52,249,223,13,55,52,196,10,134,13,83,52,247,46,88,220,139,140,46,71,86,171,174,92,145,134,38,81,64,144,44,239,228,211,160,255,38,240,178,49,186,198,31,83,200,125,95,114,75,226,81,72,40,87,216,179,181,152,216,113,156,96,51,204,212,180,119,252,200,111,19,24,175,115,253,128,212,160,48,221,164,239,13,181,27,199,193,180,243,189,67,169,225,123,223,200,193,209,255,189,204,99,51,243,7,166,1,128,212,192,81,245,93,28,154,202,172,194,57,94,130,237,120,142,205,86,178,241,34,46,208,132,233,59,181,91,143,104,92,238,202,123,38,42,167,119,135,77,235,57,76,7,104,221,249,27,79,156,203,190,253,155,71,241,72,194,210,17,122,91,98,182,79,249,30,57,192,225,87,20,205,211,123,241,193,217,136,212,71,26,244,63,100,121,48,7,220,121,55,109,106,97,199,208,100,158,49,22,100,113,72,184,204,156,49,104,119,85,227,78,63,88,63,21,12,139,185,138,235,159,149,84,113,128,30,92,133,44,52,233,45,183,34,216,7,56,130,183,76,235,16,38,252,199,143,151,191,80,173,23,3,168,174,136,104,55,228,14,148,188,35,213,71,248,55,45,77,40,54,157,187,20,48,250,139,6,185,155,163,177,165,159,212,35,63,90,138,96,1,14,116,141,62,59,21,2,30,128,157,205,223,51,205,123,92,122,245,160,231,134,82,122,139,194,139,53,106,57,142,43,112,197,170,182,61,3,29,230,235,251,171,80,157,202,214,224,88,251,10,219,220,162,196,196,82,26,59,208,29,130,201,230,47,242,122,232,34,177,26,12,4,71,233,254,227,111,240,115,33,141,6,24,128,223,206,2,77,185,45,42,16,138,155,51,253,162,109,29,68,141,114,162,96,208,239,236,125,43,73,105,154,120,111,239,223,29,74,153,165,250,188,67,159,46,170,43,195,157,140,47,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,113,95,99,95,108,97,103,114,97,110,103,101,0,0,0,16,1,0,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,246,255,255,159,56,104,44,89,83,154,193,62,43,237,248,109,92,140,242,240,222,70,221,204,94,190,15,52,131,239,20,28,0,0,0,7,113,95,97,114,105,116,104,0,0,0,16,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,70,27,90,38,177,171,158,221,170,147,13,198,54,138,226,204,148,110,146,73,81,119,23,12,222,161,93,246,226,79,8,91,230,123,248,159,182,156,214,49,187,48,5,103,36,61,189,167,16,24,80,140,231,118,215,34,213,39,141,132,202,163,4,137,121,231,101,175,33,111,169,223,62,112,41,6,254,64,71,124,137,233,55,235,17,25,13,176,224,147,137,219,71,205,39,205,168,128,18,254,168,125,116,153,20,98,36,177,85,53,193,1,96,12,91,39,168,140,160,226,193,125,211,156,20,251,43,156,83,222,104,131,2,198,21,93,179,177,226,126,241,208,80,37,246,3,172,255,57,97,165,77,154,69,161,203,236,114,46,157,218,8,34,87,46,68,177,231,199,49,50,66,181,65,252,146,198,17,108,50,21,218,186,139,154,197,176,227,130,39,47,106,66,151,84,171,114,121,237,97,31,241,72,220,186,220,85,94,64,58,151,129,188,248,51,255,32,126,53,119,0,140,28,3,0,0,208,187,224,165,203,179,81,44,109,217,184,155,120,23,9,132,132,35,209,240,40,125,224,148,163,88,235,44,49,96,191,7,137,39,174,246,19,165,44,18,155,104,127,8,254,126,33,186,122,189,160,153,36,244,179,149,126,86,6,110,26,165,25,132,7,96,73,99,41,206,68,207,250,152,219,194,66,88,239,231,175,115,24,137,40,221,42,216,114,123,53,92,27,181,200,242,96,105,10,9,122,15,217,245,201,5,120,46,123,2,222,161,210,39,74,120,128,142,91,96,89,219,147,215,17,52,87,127,221,149,76,100,207,247,91,87,85,151,146,254,102,91,248,116,38,143,157,195,23,71,222,179,13,214,57,105,36,41,106,71,160,31,178,103,146,103,134,20,151,78,81,91,101,115,171,244,205,16,59,254,245,240,9,91,31,214,34,21,41,100,37,247,205,60,199,157,146,169,168,135,71,6,51,242,43,202,145,111,21,132,48,118,253,157,5,108,48,143,203,60,33,61,183,69,168,46,25,168,231,61,234,219,1,134,95,248,25,16,186,159,94,228,220,150,0,84,141,173,176,33,179,126,33,0,0,0,11,113,95,97,114,105,116,104,95,102,102,116,0,0,0,68,97,105,132,245,126,73,66,113,7,136,146,97,207,227,18,118,119,191,135,10,54,163,151,208,249,157,129,159,132,121,115,82,215,137,149,196,15,142,48,224,2,124,174,234,58,246,185,29,105,138,46,82,158,178,15,191,250,236,19,18,102,70,236,60,9,121,148,91,198,82,111,183,41,209,149,137,85,190,69,213,7,180,70,137,29,60,254,157,16,156,47,250,36,48,183,43,116,210,61,120,88,131,114,218,40,115,22,1,250,232,91,124,50,122,89,154,216,162,93,65,18,174,245,24,107,112,64,84,135,216,181,1,33,208,105,102,77,209,83,17,0,7,14,72,153,157,64,76,119,177,178,202,235,66,229,200,141,76,35,34,180,230,75,47,86,82,65,79,103,147,111,32,111,107,1,111,200,107,234,105,172,5,242,8,35,229,192,92,241,118,234,59,201,6,199,122,236,188,113,73,54,192,166,206,63,211,21,102,109,237,171,250,248,105,171,21,234,62,16,2,108,28,125,33,49,103,1,2,147,49,197,224,90,244,183,124,4,87,39,75,118,218,145,114,145,107,167,66,115,60,133,148,192,148,157,10,162,1,14,245,226,233,10,230,41,151,74,228,60,227,7,100,248,238,157,101,255,56,100,86,176,11,13,116,115,91,174,86,30,190,215,153,187,154,202,112,12,134,43,79,240,169,92,135,18,141,204,26,184,70,107,20,75,129,117,193,19,110,229,56,230,29,157,56,207,210,205,50,190,177,137,183,77,23,93,132,95,43,23,53,96,17,140,20,147,9,125,70,203,31,17,11,44,141,187,209,212,247,30,98,35,56,243,66,99,129,53,59,98,249,207,225,90,223,174,234,113,116,207,107,0,3,127,57,226,51,81,50,230,165,14,88,183,116,172,129,118,123,84,4,242,73,9,23,235,220,209,98,160,143,240,219,187,50,245,5,103,211,227,150,201,66,147,218,93,249,209,185,119,70,20,29,204,172,176,26,0,7,49,183,136,65,170,110,43,227,168,64,107,31,125,171,254,104,227,35,79,169,133,76,161,42,112,166,148,153,238,253,34,55,102,199,164,204,10,12,183,80,222,7,131,74,70,71,43,135,143,173,201,139,84,175,221,64,98,146,149,131,148,224,233,121,103,242,124,85,202,243,215,34,170,14,113,89,140,21,207,117,27,154,83,174,84,106,56,124,77,140,123,50,174,19,107,94,148,16,148,145,132,120,54,112,255,35,27,157,223,152,30,150,242,163,233,221,28,176,5,95,140,192,76,115,178,138,68,64,241,163,136,186,187,224,155,118,27,93,12,106,139,11,21,94,39,45,40,77,67,251,152,23,199,99,180,147,22,131,232,198,178,65,53,16,87,237,33,161,149,14,51,230,249,238,35,72,216,199,4,147,18,150,174,212,184,148,139,133,90,247,236,60,23,12,62,9,16,65,45,175,147,82,185,113,142,147,198,255,250,44,161,122,128,2,164,204,62,189,89,40,232,222,202,51,137,126,178,252,82,157,198,1,137,48,224,224,239,67,8,133,255,9,21,147,7,91,113,58,95,62,49,179,182,99,206,146,85,90,146,11,154,52,247,197,225,2,133,22,84,204,245,142,174,103,240,139,182,22,204,236,225,20,196,16,162,0,145,71,11,173,18,238,250,64,24,215,153,57,249,60,62,246,127,216,7,53,27,219,219,128,237,165,112,218,40,138,107,196,136,224,16,248,90,241,13,95,202,29,229,21,229,39,106,132,144,110,252,156,78,177,250,250,166,117,200,112,240,144,68,225,194,21,201,99,112,20,16,138,102,43,14,50,108,147,255,39,209,182,198,165,133,127,27,174,223,62,118,93,197,180,76,140,127,60,6,21,253,154,169,190,140,31,173,5,70,0,103,254,228,222,173,255,209,86,188,16,137,229,203,95,148,177,57,255,20,0,4,158,46,140,113,40,214,144,206,95,62,196,187,91,110,177,30,225,252,26,34,248,91,218,63,254,9,212,60,49,165,17,159,85,107,173,81,163,225,84,181,33,208,28,45,3,32,38,177,193,139,140,118,109,61,212,73,215,158,175,251,134,172,37,115,9,245,100,52,199,198,16,55,32,41,159,208,67,238,11,100,156,175,9,206,87,244,61,51,155,66,62,117,97,213,220,87,200,122,225,160,161,168,36,116,18,249,0,49,135,125,246,247,78,26,233,241,60,119,11,255,22,83,143,191,248,105,24,79,240,55,122,139,206,176,123,140,56,228,134,212,173,48,183,136,109,111,179,245,201,27,37,120,142,2,220,213,15,162,113,202,151,108,105,209,232,59,62,125,33,175,40,120,107,176,208,153,78,99,97,209,74,222,233,26,74,64,114,93,90,166,23,57,175,165,138,159,128,144,124,231,61,13,39,106,83,127,222,250,115,157,121,81,176,210,203,200,29,37,159,10,178,127,96,149,103,253,105,170,20,130,200,192,62,249,41,171,110,250,211,6,222,108,253,142,240,40,57,76,228,74,106,110,181,166,109,174,153,53,198,61,162,204,197,22,85,210,231,110,213,57,221,240,250,28,24,60,16,124,203,158,254,94,234,134,76,183,144,39,83,100,72,153,144,205,195,132,90,81,101,90,210,234,132,246,119,60,9,6,149,111,66,183,137,139,131,130,149,121,149,136,223,62,234,191,155,89,54,8,20,10,243,32,69,225,149,197,161,76,103,59,136,93,215,195,20,97,143,48,62,32,187,66,161,171,119,85,210,16,254,97,75,89,33,101,147,57,128,96,217,173,206,180,246,189,193,249,127,202,109,123,90,202,51,193,185,34,187,156,131,233,41,86,85,1,132,88,187,67,54,213,24,204,141,136,220,171,64,67,46,88,229,16,233,111,175,161,132,16,83,50,160,247,12,64,49,78,232,43,47,94,131,54,2,176,116,20,115,246,214,172,228,233,23,33,201,252,80,150,106,87,13,178,156,76,90,145,58,142,141,146,31,222,188,44,243,111,250,76,85,16,69,223,30,181,176,67,250,235,249,169,69,16,38,208,106,246,225,50,58,206,14,229,1,71,199,23,84,100,67,18,187,53,96,77,87,83,222,75,20,184,58,94,112,222,234,190,239,201,88,41,68,152,159,224,234,21,46,188,231,120,107,230,148,35,106,241,84,31,239,3,59,126,99,46,175,42,139,33,211,42,66,142,90,144,223,85,11,144,52,154,248,61,32,160,123,164,51,68,119,125,224,209,151,36,58,77,187,172,208,161,155,155,45,197,82,201,169,234,5,114,149,99,212,35,181,208,26,253,146,133,103,162,32,216,47,198,151,87,96,111,55,141,250,46,156,208,78,117,110,148,93,236,83,110,30,233,147,196,65,133,70,37,136,134,123,186,146,3,55,169,249,131,210,253,19,96,68,22,61,213,58,62,54,120,252,138,74,99,19,131,21,219,211,159,82,118,47,235,126,91,174,221,179,125,224,123,9,65,147,205,95,243,83,217,30,90,27,100,40,253,251,14,137,140,113,154,75,58,232,175,219,253,93,197,18,118,209,237,56,255,17,33,27,105,69,80,124,58,113,238,205,53,243,214,92,4,13,112,153,220,191,58,209,168,157,35,121,188,17,246,184,201,28,38,71,10,141,233,13,161,127,49,215,31,90,139,70,23,238,162,191,1,249,24,86,144,225,231,170,240,159,227,233,31,191,69,11,121,90,131,165,170,90,222,50,84,214,52,37,53,187,130,161,3,213,187,139,192,34,74,99,188,114,41,25,125,198,90,20,181,164,213,77,70,215,121,157,80,165,210,98,251,56,103,107,19,139,37,204,174,53,98,249,230,87,250,195,144,103,3,77,146,215,146,150,108,155,154,48,190,143,218,128,242,141,31,134,31,104,245,188,39,195,31,94,8,32,1,103,167,66,152,48,147,253,58,149,137,236,157,33,165,152,227,32,73,255,33,45,108,177,147,99,169,115,96,98,56,219,116,115,208,159,196,42,25,80,250,129,140,108,23,15,239,16,41,52,116,68,205,85,169,116,128,197,119,123,89,229,19,179,20,133,93,54,32,43,249,70,88,162,121,191,201,206,213,225,218,223,191,177,86,40,178,246,189,61,108,204,43,255,136,4,211,232,26,198,213,67,132,119,155,121,226,178,134,240,142,249,87,234,197,83,85,177,139,229,29,157,78,156,33,106,104,193,38,5,219,205,208,36,100,128,1,54,4,58,100,124,145,142,119,76,252,3,126,192,56,185,96,47,67,43,163,109,70,146,22,180,239,73,91,81,104,102,179,233,83,43,161,215,152,248,191,105,253,223,154,21,226,250,19,137,46,251,87,219,225,219,165,208,19,99,46,10,242,226,88,105,97,81,104,102,179,202,81,98,75,221,254,138,174,253,247,52,238,170,218,249,57,112,226,212,146,172,18,34,47,103,60,136,168,162,173,192,96,131,224,20,104,122,158,159,69,48,62,134,169,222,43,171,16,107,193,168,24,40,34,11,51,237,98,237,47,161,203,29,57,239,200,86,215,240,157,11,226,165,252,198,73,210,157,197,223,114,180,127,231,177,154,49,224,40,223,250,238,214,232,129,203,172,85,7,159,166,219,223,3,195,164,3,178,135,47,89,54,166,46,121,67,152,222,66,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,113,95,97,114,105,116,104,95,108,97,103,114,97,110,103,101,0,0,0,16,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,251,255,255,79,28,52,150,172,41,205,96,159,149,118,252,54,46,70,121,120,111,163,110,102,47,223,7,154,193,119,10,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,219,255,255,79,158,129,87,48,1,187,50,104,134,109,127,48,137,58,78,72,159,236,101,92,248,217,211,115,101,169,128,1,0,0,0,6,113,95,115,111,114,116,0,0,0,16,254,255,255,31,216,20,60,120,221,30,141,12,111,47,152,175,69,79,253,252,146,116,95,143,172,191,156,61,26,99,55,31,130,199,23,50,136,57,76,28,175,236,196,110,18,139,39,200,227,87,190,206,82,1,155,34,148,238,243,89,226,59,112,35,32,190,214,82,59,160,71,30,40,123,194,254,163,87,202,42,42,193,138,239,112,161,227,200,233,60,102,16,173,101,82,42,200,45,139,244,145,82,33,192,81,208,39,61,76,32,147,197,252,77,117,111,158,111,227,164,210,80,23,30,79,233,28,22,198,119,110,199,149,153,171,225,216,128,128,149,186,127,185,195,101,98,197,250,23,212,0,163,124,84,121,13,212,228,205,45,218,187,158,22,132,2,130,3,108,171,112,11,234,3,182,80,238,47,195,107,235,89,105,237,36,206,251,67,69,12,117,26,179,176,46,9,219,20,237,136,202,216,196,41,81,217,52,88,18,189,147,104,235,30,105,61,105,71,58,215,137,152,221,14,250,164,22,29,208,33,202,171,53,85,25,159,160,159,205,103,191,98,102,152,92,101,157,144,122,79,173,184,110,197,246,42,3,0,0,208,187,224,165,203,179,81,44,109,217,184,155,120,23,9,132,132,35,209,240,40,125,224,148,163,88,235,44,17,127,56,232,189,11,188,149,39,226,131,244,10,54,93,12,96,121,0,195,178,99,68,181,149,149,177,61,135,144,18,244,12,225,65,41,157,88,85,154,37,105,245,246,122,164,144,105,253,50,151,246,145,69,164,108,239,63,99,203,208,197,232,17,6,57,210,116,251,1,163,192,131,63,160,145,60,252,199,160,98,96,10,12,18,24,214,108,19,87,79,26,195,35,101,71,26,60,136,145,24,146,81,24,166,73,96,242,93,214,80,174,140,84,78,61,8,85,183,159,205,214,235,233,180,17,184,250,50,39,68,97,217,15,243,95,64,37,197,72,110,94,228,125,215,110,40,190,21,203,235,230,202,4,210,53,157,45,66,239,21,78,79,209,230,184,224,244,186,198,151,244,79,247,14,255,207,74,155,237,24,203,38,231,122,192,88,247,9,233,181,134,33,7,91,233,210,195,211,23,152,91,27,160,218,167,72,102,192,157,245,26,233,89,224,178,39,175,80,132,40,4,137,109,5,0,0,0,10,113,95,115,111,114,116,95,102,102,116,0,0,0,68,93,154,143,49,232,95,4,84,143,150,218,210,164,194,121,30,176,103,222,64,154,151,217,150,26,210,132,192,16,5,184,47,243,236,185,8,94,4,65,121,185,228,139,235,134,94,71,58,57,42,232,30,186,28,184,227,128,215,240,3,251,200,99,65,241,169,201,99,141,81,135,27,70,42,95,8,117,27,126,118,215,172,105,206,249,153,60,156,0,237,62,55,177,42,90,82,239,115,99,198,9,194,218,161,32,221,15,172,41,105,81,209,36,19,166,228,239,154,170,126,183,241,35,201,101,139,167,8,78,47,160,144,23,126,184,16,146,194,135,117,68,110,33,119,235,120,68,101,95,146,106,190,189,200,221,128,180,159,133,89,238,154,236,241,134,175,38,255,87,29,120,85,95,39,74,30,190,182,231,177,153,125,156,134,178,186,66,27,35,2,216,81,116,155,40,23,215,99,88,54,186,128,12,137,241,83,134,191,234,11,192,121,91,22,114,249,182,47,197,78,14,8,166,34,119,199,67,90,66,221,246,12,133,115,228,69,120,160,230,6,212,242,151,114,180,24,210,105,166,137,45,214,47,242,211,62,18,95,210,239,62,188,10,147,123,76,162,159,81,46,239,137,234,149,125,198,233,96,39,225,228,213,232,68,138,3,119,94,60,111,72,242,72,72,153,156,123,204,126,125,148,253,126,195,137,114,150,244,19,40,226,132,14,96,108,255,123,105,53,84,140,128,150,200,133,142,28,32,136,164,239,135,247,165,217,199,227,45,245,226,152,40,34,17,142,0,17,59,169,222,52,25,217,7,27,156,130,83,246,171,188,176,57,157,85,166,125,97,181,80,168,105,195,187,182,111,189,195,135,143,21,250,70,58,9,138,159,27,44,125,232,184,97,148,219,13,212,222,152,121,164,249,140,76,212,40,112,176,33,167,27,68,172,103,250,32,171,30,181,101,244,195,236,22,181,144,92,56,209,67,40,149,159,63,166,170,209,57,59,29,119,54,51,222,8,195,56,93,115,55,249,115,196,214,240,140,152,239,151,202,249,179,89,93,236,184,163,122,13,159,127,108,87,64,168,35,172,110,66,37,131,35,94,164,112,14,178,167,137,144,131,135,182,255,164,13,84,118,210,50,155,9,109,241,121,86,54,213,153,203,174,59,56,143,11,197,51,51,60,159,196,22,177,69,79,71,29,172,79,48,13,142,41,37,32,230,85,19,149,172,176,82,156,43,225,147,137,172,218,192,218,181,244,131,207,116,41,199,32,245,187,109,240,211,2,153,5,149,176,147,240,49,97,13,139,28,119,215,28,196,243,25,102,216,39,26,100,61,63,86,186,228,160,43,106,11,10,80,246,95,233,197,56,51,201,226,130,17,125,195,156,245,97,192,230,211,53,241,116,226,118,181,166,18,52,34,238,171,35,146,100,15,105,200,138,64,202,164,52,89,247,212,81,221,196,244,33,227,44,1,255,154,157,167,41,11,254,70,33,110,242,94,99,74,16,83,193,200,139,132,165,6,239,55,40,57,225,208,223,44,142,141,251,220,168,97,173,155,58,83,43,241,197,51,180,145,17,109,111,128,218,135,205,68,202,37,111,35,42,196,12,228,186,80,85,139,140,34,20,20,17,184,14,74,193,201,169,14,249,56,225,236,49,16,77,3,30,29,228,9,151,41,15,118,185,79,163,105,192,23,240,154,247,131,188,60,187,55,36,173,52,153,195,54,169,53,220,92,113,214,202,14,60,66,101,222,74,203,211,22,213,182,113,70,15,240,211,16,7,238,190,162,236,43,56,133,20,141,30,4,53,74,19,224,183,169,91,196,13,222,134,155,171,234,159,97,139,116,145,225,81,180,86,4,254,77,143,181,113,240,203,47,128,226,209,222,152,97,198,38,196,124,210,72,127,111,186,166,24,23,58,32,48,83,154,150,39,247,63,186,199,87,1,42,119,80,40,154,37,35,110,187,215,99,187,76,124,13,39,149,155,1,191,241,239,42,254,70,211,16,222,195,74,191,212,46,181,51,120,89,120,154,119,217,239,231,174,165,61,190,43,160,203,193,77,155,66,235,67,14,143,6,238,133,134,14,248,0,230,199,105,51,33,165,62,34,201,212,133,47,63,98,183,155,38,70,3,99,249,158,67,152,70,12,99,143,211,55,215,91,138,214,205,17,176,86,179,86,83,209,122,75,172,160,6,144,166,220,161,248,163,168,138,76,216,41,172,33,208,15,207,23,172,22,105,179,198,212,68,83,135,149,16,251,154,62,48,214,230,159,230,103,253,152,123,52,31,195,59,145,185,101,131,57,217,52,62,32,39,26,29,127,9,109,157,88,181,38,94,52,120,35,115,205,228,227,57,94,207,63,72,172,131,8,133,42,191,173,16,176,21,164,28,253,150,225,13,126,129,38,174,183,161,118,28,124,221,216,105,102,204,190,143,81,11,206,41,74,49,38,121,50,204,254,46,132,104,157,254,204,210,184,247,142,17,1,86,2,172,137,76,127,211,175,220,253,247,223,192,2,85,90,85,41,149,147,52,122,80,134,42,69,211,184,53,66,135,79,36,198,133,29,89,21,160,97,224,54,16,43,16,43,206,249,84,136,189,86,147,184,132,36,133,87,171,182,42,76,97,190,7,94,101,92,38,143,61,78,56,154,246,125,226,67,252,144,224,65,245,115,186,98,241,30,162,202,185,28,47,169,248,183,98,110,77,92,211,224,211,154,4,204,37,229,204,36,180,116,73,241,44,225,91,77,226,132,240,56,34,133,141,165,25,49,126,64,252,241,142,65,88,6,148,137,236,248,197,86,191,222,154,169,177,72,132,19,155,173,104,212,228,217,139,27,136,67,160,231,125,218,107,251,62,189,233,45,96,66,162,23,222,129,186,99,106,206,83,4,121,26,86,54,69,85,63,60,123,149,236,55,3,26,109,155,152,13,148,191,193,34,167,60,146,5,166,117,27,140,237,150,116,202,148,91,121,226,213,35,28,203,48,223,74,148,213,89,40,29,90,7,197,43,252,41,140,66,128,84,64,208,111,166,145,45,223,216,140,69,74,239,175,196,87,206,89,84,235,219,161,235,49,236,94,160,64,87,223,165,119,63,188,165,40,162,205,158,133,168,36,203,51,15,243,43,108,213,132,79,149,71,245,150,129,161,243,47,101,13,57,181,230,254,14,219,151,2,188,161,63,167,90,168,136,255,11,227,212,96,93,60,210,246,200,121,228,84,196,150,178,71,7,242,93,108,44,138,239,120,114,82,49,116,158,255,83,112,199,205,79,186,199,205,99,100,199,121,149,32,222,202,83,64,253,151,23,201,157,220,172,184,6,151,231,202,79,109,43,17,123,53,26,99,51,18,237,70,227,157,115,148,253,50,111,9,169,128,109,249,153,144,207,238,221,111,119,3,101,224,174,228,161,221,123,168,146,253,97,20,72,91,7,95,10,199,238,67,238,45,195,160,75,146,207,133,36,67,184,179,82,178,8,54,30,250,161,79,121,126,53,67,81,35,74,107,188,193,47,25,125,35,24,105,200,6,145,130,203,31,17,97,107,158,102,173,67,145,75,69,234,128,225,191,217,152,152,40,28,209,248,92,189,0,139,162,75,136,7,59,128,158,76,99,144,95,132,231,32,163,2,178,95,13,200,246,136,27,245,47,206,133,249,16,109,74,213,79,169,225,0,26,10,98,229,178,179,110,150,149,83,103,78,213,252,130,42,184,85,255,235,249,240,179,72,63,243,187,112,67,62,4,124,14,194,216,127,119,108,37,21,54,8,6,109,169,237,207,112,245,228,97,171,222,74,79,1,28,31,92,232,152,204,20,60,77,7,25,76,249,164,173,88,65,14,42,227,58,167,191,178,219,59,45,167,44,1,51,237,11,42,137,101,61,39,130,104,236,38,120,218,18,39,247,102,173,143,46,220,56,217,207,146,28,11,105,159,216,97,207,32,35,184,166,39,218,82,229,56,247,237,26,0,143,195,62,61,138,43,101,9,53,250,161,112,67,137,208,12,115,154,100,147,26,185,220,137,134,188,195,184,249,230,228,93,159,124,236,3,23,120,88,69,95,227,39,206,15,204,105,12,199,36,134,79,54,189,209,45,159,231,181,169,128,133,51,238,94,96,147,105,140,89,85,19,154,151,68,229,3,40,171,220,79,37,168,214,0,36,188,171,42,193,165,143,127,110,184,177,128,184,6,8,136,27,31,164,228,96,153,175,223,64,21,44,116,18,50,160,83,231,232,11,240,17,95,41,39,106,76,68,132,136,70,144,43,196,30,30,40,156,132,100,35,220,162,208,104,237,75,212,80,113,178,203,113,21,147,189,219,96,92,86,196,199,86,216,35,125,9,204,87,247,65,194,70,62,198,179,167,111,17,190,22,136,132,9,191,154,89,99,237,253,196,36,177,103,247,147,139,81,208,224,195,47,62,195,67,137,22,147,4,0,154,239,1,186,144,91,4,137,74,4,251,229,32,188,218,240,38,53,109,239,16,247,122,50,238,195,42,23,228,148,54,94,192,53,8,192,23,239,171,81,222,153,240,45,154,77,96,246,61,209,61,172,26,180,71,102,129,26,171,25,173,196,215,150,153,7,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,113,95,115,111,114,116,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,214,255,255,159,186,181,237,220,42,136,147,7,28,228,123,103,183,128,199,192,14,144,212,194,39,185,219,13,39,33,139,15,0,0,0,10,113,95,101,108,108,105,112,116,105,99,0,0,0,16,254,255,255,31,216,20,60,120,221,30,141,12,111,47,152,175,69,79,253,252,146,116,95,143,172,191,156,61,26,99,55,47,114,192,90,60,84,67,221,174,32,46,47,158,98,130,31,247,200,204,53,136,15,80,218,56,92,4,230,236,193,47,197,27,228,149,49,189,66,148,16,34,141,202,154,126,152,162,35,112,79,25,124,13,159,21,0,2,135,4,115,178,98,178,156,47,129,147,28,51,228,124,37,248,91,202,204,196,85,132,69,94,188,247,99,61,146,221,127,249,236,58,218,1,121,134,224,24,190,70,92,140,153,148,247,10,135,124,229,140,123,193,9,158,108,12,253,24,82,186,36,237,236,70,67,102,152,102,60,15,85,147,114,157,111,197,249,50,181,100,112,46,85,202,191,208,212,63,219,56,187,115,2,29,223,223,46,52,49,154,170,17,202,134,84,224,242,240,119,164,62,90,17,155,168,229,91,220,238,11,151,230,90,110,72,120,112,148,224,222,162,252,247,46,153,121,185,36,165,232,74,16,184,35,142,148,130,89,186,10,0,217,18,139,154,0,157,116,95,145,118,215,127,138,60,36,4,0,0,192,79,214,135,15,69,194,229,230,33,161,207,160,116,97,5,6,218,22,65,225,166,128,198,132,203,57,145,49,143,63,165,179,63,178,4,149,112,66,138,219,229,101,20,49,148,139,75,249,166,245,117,127,205,155,75,244,176,30,159,20,30,106,206,34,229,86,179,101,149,22,216,116,248,45,68,224,106,151,134,245,205,117,160,110,204,59,240,15,131,234,43,49,128,108,227,188,175,120,188,75,53,166,236,180,242,99,238,201,160,96,29,68,36,104,208,190,60,101,87,223,249,199,131,23,67,185,163,99,250,96,234,56,10,244,211,236,204,38,42,138,240,75,132,104,100,139,43,203,60,89,238,122,218,231,39,33,172,108,141,82,36,48,232,16,220,11,73,75,243,29,116,87,136,24,166,72,251,209,77,155,74,192,2,173,65,180,185,30,56,121,171,255,52,250,75,227,227,134,97,88,232,234,11,116,203,164,107,28,18,29,88,248,226,171,130,227,66,160,208,49,104,134,70,203,238,12,151,51,217,76,43,229,197,142,121,29,93,127,110,246,27,69,179,67,202,14,187,9,243,195,39,12,0,0,0,14,113,95,101,108,108,105,112,116,105,99,95,102,102,116,0,0,0,68,169,141,193,177,252,167,249,183,151,115,219,154,20,114,92,17,201,181,138,249,177,228,210,142,109,8,8,237,29,163,212,71,144,42,209,95,62,115,18,235,136,102,158,33,244,234,72,74,0,86,179,112,118,192,192,162,55,182,202,110,60,86,6,7,47,223,66,146,12,253,123,182,124,225,51,154,218,97,71,192,102,183,6,56,130,36,186,120,155,150,0,2,57,230,152,86,109,226,47,125,253,88,146,222,214,6,201,240,87,19,130,16,149,0,107,177,4,247,137,165,243,163,110,222,160,6,201,15,54,53,180,158,23,32,4,28,230,53,52,47,142,197,170,223,101,173,74,239,171,106,171,115,140,169,226,6,98,202,6,16,75,46,42,220,72,13,34,12,150,12,220,228,20,126,236,3,80,171,3,7,4,217,51,141,233,217,197,85,145,199,199,55,226,174,13,2,136,117,50,219,136,88,81,125,75,42,93,131,57,97,55,168,75,54,120,252,152,5,5,168,214,161,200,14,101,64,140,51,9,2,48,147,118,191,30,228,71,9,150,4,221,195,153,79,203,30,198,181,182,206,231,75,209,171,86,28,243,170,204,225,205,160,145,112,85,201,110,59,193,49,236,104,51,154,107,221,226,245,231,86,109,232,7,244,235,129,200,45,34,125,145,40,244,128,89,42,49,125,152,86,218,0,161,63,79,60,231,176,132,4,6,193,209,123,143,45,255,160,37,22,158,80,169,121,32,27,17,198,97,81,202,181,218,206,238,212,206,127,20,64,135,144,110,175,180,240,11,211,183,161,141,52,211,104,158,129,172,233,22,213,48,72,240,199,206,245,114,64,99,215,43,133,206,68,83,46,6,232,32,4,23,1,31,11,74,123,19,33,31,78,137,199,219,216,95,128,165,125,197,99,205,109,238,5,56,37,116,175,0,232,120,112,211,42,13,31,128,194,107,120,91,160,85,64,149,152,194,49,48,213,185,152,112,134,106,111,231,134,196,91,54,1,135,229,254,61,186,86,98,94,120,120,25,43,252,104,230,211,254,79,166,91,37,34,68,7,233,58,129,190,65,109,124,76,220,116,137,109,41,72,243,231,233,62,39,148,51,99,100,120,206,42,146,40,70,160,251,67,156,40,170,144,124,138,57,133,106,251,161,7,255,48,30,1,173,77,6,196,65,239,11,201,173,180,240,7,109,121,252,125,77,62,24,228,147,234,150,21,246,224,147,142,171,0,94,198,26,116,215,207,251,103,242,182,235,13,78,75,242,246,196,168,191,223,34,137,236,40,75,18,58,221,177,51,116,74,102,114,160,186,228,27,239,251,126,203,71,52,16,30,88,166,32,156,7,29,194,34,255,194,171,18,198,181,240,200,191,25,236,91,80,190,241,94,246,195,1,169,175,114,248,26,219,91,64,15,123,16,214,248,30,30,92,29,221,187,91,136,28,70,151,15,252,230,163,103,228,235,245,127,79,215,226,65,201,153,70,243,150,13,62,25,10,67,161,81,49,127,94,13,235,61,236,62,77,238,27,20,22,215,192,188,24,142,158,162,245,107,80,144,255,253,62,125,164,66,143,238,113,75,49,116,15,35,132,10,221,91,222,212,119,51,63,15,11,120,20,149,189,20,89,145,113,84,66,55,187,122,55,152,98,83,14,237,1,40,192,160,32,7,7,161,5,110,178,52,211,161,57,68,243,135,211,185,177,65,179,68,60,64,18,52,133,83,21,51,200,19,64,49,164,2,101,161,151,85,51,135,48,36,239,88,109,178,98,155,63,164,199,8,93,184,142,157,234,154,91,35,250,46,124,179,21,86,6,219,91,246,5,68,157,60,28,95,231,188,63,36,84,142,0,165,255,105,205,211,179,0,235,11,235,71,208,30,172,250,203,45,159,171,92,204,236,49,111,189,145,187,251,89,65,36,150,157,109,137,12,246,135,177,192,130,65,47,134,90,109,203,60,38,88,219,100,254,137,229,52,108,210,172,218,12,39,192,4,249,231,230,242,6,128,120,2,225,187,58,45,58,167,206,114,63,253,145,181,191,195,1,105,149,120,43,133,83,201,224,133,200,122,77,154,3,80,76,53,252,160,67,226,0,215,101,150,1,157,83,245,122,43,186,80,96,7,145,165,172,66,174,143,222,15,33,176,53,106,216,247,227,6,67,91,145,7,24,33,68,145,112,89,207,123,182,175,122,250,23,36,194,85,215,74,236,7,232,8,71,149,109,45,222,175,14,130,57,214,129,41,106,158,223,128,96,79,151,146,58,16,69,18,32,164,85,248,46,51,247,151,11,252,51,170,249,229,88,117,251,69,118,77,116,102,202,41,93,51,110,203,86,23,190,56,181,114,24,97,93,71,203,237,179,220,166,56,110,45,90,118,195,18,244,182,129,90,193,74,91,77,67,18,128,118,107,36,216,78,122,249,214,240,113,129,74,182,54,40,67,23,41,249,74,200,26,27,139,252,243,37,36,218,10,117,3,56,108,226,70,115,181,151,157,204,40,28,82,213,99,14,15,213,93,159,5,128,88,139,236,13,191,191,240,187,97,192,254,91,241,61,2,248,109,164,21,210,4,186,105,253,112,106,127,51,18,8,153,95,53,250,62,158,160,57,37,228,224,146,7,189,191,68,12,41,170,95,57,31,175,15,192,203,37,82,225,119,88,27,163,28,242,169,199,32,237,134,170,25,199,44,12,59,42,201,98,110,219,251,164,197,128,25,94,236,20,145,90,52,17,74,163,114,151,136,98,22,245,53,221,49,67,162,65,37,70,14,75,205,135,96,173,152,109,14,183,45,170,208,144,108,73,151,58,206,92,122,16,113,158,96,241,44,126,42,210,3,196,4,119,196,116,132,94,227,17,236,40,205,143,122,20,163,32,25,210,49,188,8,208,244,49,91,201,213,129,183,81,160,197,228,37,201,189,250,136,158,100,44,87,161,206,67,204,240,31,68,198,90,232,57,192,210,216,158,7,153,104,182,164,67,94,104,142,182,154,102,53,252,246,194,248,248,239,160,157,34,35,220,74,16,119,234,217,106,245,105,234,100,189,209,177,229,48,186,184,224,69,83,86,240,130,215,184,237,119,190,62,146,25,155,154,102,69,38,249,233,126,185,128,205,76,146,193,32,22,125,220,73,64,44,2,146,39,217,253,215,113,192,95,30,21,224,139,195,96,190,151,110,90,225,103,240,236,92,64,115,218,97,84,191,60,50,123,162,222,252,212,90,131,206,95,156,74,72,176,233,119,36,186,137,240,210,170,238,81,155,252,100,3,140,242,201,129,55,80,250,135,5,93,206,64,8,206,106,78,254,138,58,236,220,41,25,77,175,132,163,107,93,58,152,138,170,85,143,193,84,20,57,13,217,77,166,60,59,5,39,77,189,48,155,202,102,78,75,64,54,191,245,26,32,87,10,84,237,213,217,171,215,238,147,39,130,114,144,109,170,199,251,21,172,147,219,16,250,1,130,103,173,167,157,40,175,194,214,70,121,143,246,25,182,63,176,217,197,207,255,176,144,205,110,40,236,39,59,0,37,238,117,40,106,93,31,129,11,1,243,233,49,44,4,125,117,133,171,228,218,167,236,224,55,58,89,74,214,96,220,128,0,43,191,255,23,45,21,23,230,74,188,27,5,209,84,154,230,110,15,115,51,251,151,235,101,162,162,85,186,243,207,3,98,196,211,146,240,39,46,221,92,203,40,207,3,93,7,95,202,167,253,91,38,123,106,76,103,25,243,40,113,211,222,145,174,200,214,214,163,73,202,216,254,82,196,77,166,37,10,238,198,207,0,239,17,50,14,38,201,219,91,13,164,103,5,154,172,203,65,163,203,58,102,33,171,40,190,214,184,18,241,115,9,102,131,70,18,231,147,143,162,177,219,67,80,58,18,25,155,10,223,188,152,219,128,80,66,196,58,129,167,182,24,65,29,94,97,202,75,142,152,60,36,36,208,75,144,155,108,37,145,247,1,250,220,142,153,122,228,206,184,35,46,234,43,253,239,251,46,36,196,10,160,162,160,31,74,78,80,24,91,153,129,157,115,176,113,115,18,36,3,237,221,116,123,216,253,250,40,228,189,90,0,195,199,3,27,237,12,55,246,139,19,253,79,158,21,238,189,244,42,18,48,37,62,213,132,153,103,127,5,77,208,97,198,124,124,239,7,105,123,67,168,51,1,88,175,159,144,173,51,55,235,83,107,19,239,100,208,246,119,192,177,105,125,31,212,199,24,82,27,17,226,69,2,102,13,204,126,222,198,12,231,34,145,176,209,251,160,5,238,92,79,122,121,146,58,110,233,170,173,175,83,194,50,0,191,40,5,162,197,6,185,206,218,249,169,173,151,228,76,35,161,95,149,114,127,129,144,216,0,11,132,64,207,73,137,19,26,181,234,6,98,186,241,238,46,206,2,33,157,94,58,229,184,66,222,61,172,235,139,36,132,25,87,230,178,219,145,50,211,2,231,8,157,65,48,241,0,42,24,203,77,162,54,97,176,77,248,44,248,229,168,18,227,88,126,7,179,1,236,93,182,250,108,1,244,46,233,38,81,108,228,56,36,149,35,117,71,237,167,13,38,70,221,111,105,2,90,240,227,239,191,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,113,95,101,108,108,105,112,116,105,99,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,209,255,255,239,214,233,131,137,84,85,244,166,177,90,120,158,229,198,64,57,126,51,67,41,87,152,227,167,232,152,149,29,0,0,0,5,113,95,97,117,120,0,0,0,16,253,255,255,47,68,31,90,52,76,174,211,146,38,71,100,135,232,246,123,123,220,46,15,215,130,31,107,92,167,20,211,14,98,185,157,70,32,77,110,65,146,111,153,205,178,121,23,38,174,65,173,65,204,158,25,79,36,26,216,127,161,35,26,20,167,109,140,55,182,146,247,225,96,169,185,132,68,5,73,141,23,25,236,169,22,68,204,130,250,43,78,115,165,176,130,4,58,249,173,113,54,167,41,48,102,196,113,76,95,232,247,246,123,161,82,11,134,75,28,78,7,37,157,229,162,35,164,27,183,21,74,65,49,133,37,120,198,232,3,254,132,235,141,160,208,14,182,184,66,230,152,239,134,217,62,160,207,54,15,33,208,106,70,36,91,136,113,98,254,29,112,81,192,144,201,80,187,79,243,5,139,141,155,76,153,241,97,36,29,40,224,8,224,92,122,199,118,215,32,124,33,107,164,146,183,9,79,56,110,2,25,227,19,120,215,250,77,65,85,5,73,18,174,30,56,78,92,44,122,175,203,116,58,242,2,138,100,19,167,173,64,79,191,125,216,155,156,88,68,211,63,246,144,79,130,29,4,0,0,192,79,214,135,15,69,194,229,230,33,161,207,160,116,97,5,6,218,22,65,225,166,128,198,132,203,57,145,33,159,70,98,169,115,168,115,2,255,0,32,172,149,110,28,2,175,22,212,63,234,166,54,105,5,134,89,97,209,42,74,28,90,146,115,184,221,98,234,97,48,199,255,244,3,227,234,154,69,63,149,215,159,1,132,53,47,116,227,109,205,157,225,43,199,6,82,126,93,78,184,19,43,172,71,45,233,255,59,49,225,182,46,118,48,250,51,106,34,123,148,251,207,42,192,20,74,234,181,174,98,112,188,203,202,135,181,123,195,252,165,135,140,73,203,200,115,95,183,200,162,198,242,64,163,23,85,15,49,149,185,203,56,109,112,225,146,82,73,40,136,87,106,215,161,8,142,123,43,184,180,107,144,174,207,188,85,38,132,39,33,163,133,40,29,30,193,199,111,5,21,231,144,222,228,239,238,85,104,158,162,205,120,189,219,94,220,219,41,60,182,17,201,177,163,195,25,70,22,207,86,126,182,239,227,212,140,122,28,9,194,3,222,169,179,95,229,204,241,234,225,254,225,18,0,0,0,9,113,95,97,117,120,95,102,102,116,0,0,0,68,245,128,243,49,17,240,238,27,160,80,220,98,132,33,63,4,226,3,55,178,201,49,204,134,192,62,139,25,43,65,241,95,47,104,232,150,70,205,167,228,122,201,35,75,242,71,178,170,129,50,129,197,159,239,105,210,65,213,7,156,99,128,113,45,109,20,188,192,139,168,112,81,179,152,8,44,64,168,16,10,246,193,163,161,10,175,55,85,54,64,194,204,192,161,215,90,236,80,252,35,133,229,43,95,30,161,59,175,206,165,230,119,98,70,177,255,207,152,185,132,89,246,234,212,78,208,78,71,32,59,200,140,63,173,19,175,92,138,83,220,104,237,155,152,154,146,83,124,101,206,140,153,174,202,74,79,245,145,80,39,168,193,103,198,10,107,29,25,212,251,63,116,202,212,142,233,225,159,31,92,110,52,203,147,32,249,72,144,255,140,183,29,81,194,242,220,204,124,238,195,232,160,79,235,237,232,103,111,229,14,48,88,242,155,206,183,164,123,118,226,17,138,79,43,85,185,212,236,247,17,45,161,138,236,203,117,168,66,173,82,160,69,158,47,79,176,90,114,26,84,5,132,88,2,162,90,214,246,198,179,132,112,220,213,81,39,174,202,193,5,81,152,54,79,92,247,72,22,73,61,73,59,138,101,51,157,226,93,10,139,218,62,199,164,221,63,9,15,37,35,177,212,42,12,207,182,58,112,98,108,202,109,232,215,21,30,104,117,222,56,176,32,188,42,187,167,5,108,59,254,164,227,189,247,3,226,185,209,51,157,117,248,186,77,219,224,6,107,198,100,230,79,207,201,33,71,254,106,251,133,199,192,25,230,216,21,208,111,203,14,178,163,70,89,144,93,162,76,29,59,254,164,191,60,139,108,135,38,18,31,42,214,85,29,228,242,118,28,242,77,246,225,79,191,155,33,120,174,223,40,214,156,250,237,31,29,84,102,34,155,46,135,220,37,228,47,111,177,70,126,23,116,228,116,173,178,70,142,253,225,203,43,169,11,130,106,215,31,80,133,247,140,218,137,37,1,163,71,172,91,10,27,189,190,62,253,172,121,62,152,179,181,119,184,222,228,243,29,172,58,99,172,117,217,221,25,181,30,63,96,25,206,109,81,231,50,163,17,102,30,185,23,140,35,249,179,158,33,170,67,79,38,5,115,78,198,108,74,41,131,228,235,99,157,218,176,240,110,6,36,15,112,189,232,87,167,1,184,136,246,233,24,31,6,218,248,171,75,64,233,58,214,94,121,78,45,42,231,143,208,112,139,13,106,140,51,131,4,188,240,81,167,143,11,249,71,86,13,36,161,105,19,90,99,103,237,228,164,41,206,41,144,253,100,38,176,48,59,88,222,151,255,132,25,139,253,96,82,91,244,3,135,129,253,5,180,205,96,234,2,122,128,15,165,76,252,7,117,136,95,217,44,79,114,47,55,237,107,4,51,53,74,166,16,91,239,226,108,156,29,45,32,151,11,1,216,212,238,9,170,28,72,16,203,222,15,62,115,75,249,103,20,233,69,114,163,86,87,76,129,243,235,53,63,148,227,61,60,102,205,211,10,184,198,148,243,12,112,116,22,136,96,81,1,61,239,74,164,254,239,0,63,50,93,7,235,83,31,51,237,67,18,83,221,12,95,124,46,76,87,178,216,119,123,82,28,101,36,93,212,50,249,161,49,95,107,47,71,140,41,146,237,198,248,42,203,206,34,69,252,108,175,219,19,218,27,225,91,15,140,125,246,141,0,202,204,27,67,141,49,9,251,104,30,182,70,171,55,136,35,251,205,48,15,157,176,162,185,213,89,195,28,24,204,84,12,92,40,254,169,179,221,140,211,46,24,244,211,22,59,175,149,168,207,156,89,216,75,100,39,10,96,32,91,134,22,255,249,119,48,245,27,7,27,95,11,105,208,222,156,72,40,252,231,64,124,241,244,207,168,185,173,129,52,148,100,178,12,192,51,96,183,96,40,159,4,165,226,73,156,188,191,13,13,99,129,129,206,232,92,240,75,71,180,62,22,163,64,214,99,69,249,190,194,88,182,101,106,3,156,93,102,132,52,66,35,92,26,17,28,82,192,78,80,254,76,129,37,223,57,68,136,159,83,221,200,178,145,138,190,170,70,139,174,129,107,3,123,220,99,44,98,67,255,162,2,143,222,154,90,45,76,65,14,38,39,81,206,240,61,54,155,251,60,34,200,254,255,138,55,168,117,213,59,99,4,176,154,253,250,244,53,86,92,67,112,100,20,52,228,87,74,27,64,249,101,136,99,131,239,94,64,134,57,74,73,189,19,89,20,181,240,127,23,15,194,77,236,75,227,235,141,39,108,86,144,80,182,104,247,62,150,111,96,112,75,180,199,184,231,13,223,7,55,13,41,45,217,20,56,88,95,152,133,254,212,140,8,163,217,62,31,167,57,129,120,21,213,119,125,54,214,220,27,69,184,4,8,191,111,23,35,66,44,6,220,192,201,66,85,134,125,16,249,248,219,141,101,22,38,172,97,17,180,106,7,63,161,32,88,234,176,170,119,21,59,201,71,192,203,6,248,245,44,182,200,81,13,77,151,121,83,155,172,253,17,76,140,55,34,187,41,64,56,106,2,15,60,229,0,204,68,208,118,233,135,231,226,109,169,71,243,236,138,119,94,142,241,251,238,199,167,68,12,60,181,88,130,134,6,75,255,62,23,4,183,48,204,174,251,83,190,124,75,23,121,88,145,178,97,55,32,226,108,100,94,223,209,155,77,80,238,238,88,248,196,185,211,217,21,137,190,165,12,155,77,14,35,82,225,154,199,149,233,65,218,174,11,111,150,1,16,67,216,93,41,38,53,241,39,112,202,123,108,129,170,232,1,139,226,90,40,153,148,176,241,148,230,163,41,84,34,169,20,167,209,149,95,61,120,85,205,41,78,1,79,78,182,165,67,242,247,207,45,192,160,174,221,197,117,58,3,246,134,15,91,88,244,183,26,201,68,157,117,243,102,177,152,180,81,60,86,130,214,34,148,93,212,151,216,124,15,73,28,46,83,160,121,188,206,41,204,100,136,93,149,167,238,232,194,126,93,108,192,185,227,149,154,96,198,12,198,3,122,172,60,87,143,85,75,144,76,171,91,165,98,21,241,255,183,13,29,7,141,39,171,211,180,142,7,189,100,46,66,141,143,215,28,135,98,160,194,109,84,69,178,6,46,161,50,95,216,93,181,183,197,169,24,7,186,114,198,48,48,209,177,216,40,134,77,136,110,117,147,136,244,65,36,162,146,242,181,79,17,66,110,243,190,194,199,240,140,64,243,25,160,213,127,191,130,29,44,254,125,93,31,136,129,163,157,198,1,166,146,34,31,209,219,124,29,131,158,191,208,52,27,165,93,167,3,6,137,122,96,211,224,200,123,91,247,138,25,177,239,230,37,108,158,205,19,243,126,58,178,137,107,102,171,15,202,124,62,48,101,209,72,105,249,243,144,20,124,82,5,165,155,201,35,195,234,112,47,119,204,201,98,60,187,218,183,16,220,131,21,242,138,73,7,90,44,94,167,237,223,120,138,119,42,116,39,99,123,75,254,194,110,59,51,74,68,37,81,178,22,15,184,224,84,85,7,236,192,45,143,249,236,208,248,251,105,177,93,98,125,88,215,209,245,34,254,73,255,101,198,96,250,165,3,165,211,30,9,7,157,202,183,26,167,166,11,215,237,118,7,6,40,187,8,180,82,192,232,151,204,208,255,246,246,232,158,221,126,157,18,241,234,76,192,70,120,245,38,168,155,135,45,34,81,219,181,254,245,169,53,13,91,49,89,146,66,212,47,45,5,127,95,39,115,34,187,100,151,131,113,109,123,13,86,32,211,187,27,169,74,252,169,254,128,179,64,149,96,29,48,94,147,1,27,117,235,190,4,123,157,115,73,121,206,109,20,21,169,218,44,98,230,211,199,170,166,223,191,98,19,96,191,115,42,27,68,103,144,177,128,59,20,233,184,58,146,121,236,188,118,0,149,211,22,205,67,47,16,157,76,213,164,1,241,51,140,156,81,231,83,44,172,70,119,46,103,252,1,199,168,137,237,183,210,126,88,182,150,110,160,173,165,52,28,131,64,17,84,202,55,45,70,249,122,144,155,189,211,211,212,244,209,110,230,170,205,245,44,185,97,6,202,26,79,17,14,185,204,4,141,87,37,44,171,86,133,157,153,145,219,248,181,36,39,30,32,214,65,133,206,75,156,2,58,75,95,103,122,5,48,36,240,35,56,32,227,14,120,167,62,10,190,23,75,10,74,244,105,77,88,47,164,4,81,122,113,1,226,115,147,31,154,18,36,190,64,13,159,62,210,117,122,180,193,84,151,253,150,103,114,193,34,197,181,94,141,7,193,94,106,195,79,84,217,46,130,84,16,171,229,203,94,149,37,158,172,206,102,39,23,138,221,172,22,195,92,90,54,114,83,4,77,85,124,233,230,242,206,207,50,233,116,114,61,245,87,182,27,104,225,71,78,209,100,156,220,89,129,117,90,154,12,157,209,49,237,210,52,175,87,117,34,174,221,234,54,190,106,252,228,150,31,238,4,227,188,221,252,156,112,158,214,82,150,64,165,12,152,82,203,22,227,64,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,113,95,97,117,120,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,204,255,255,63,243,29,26,54,126,34,85,70,71,209,116,213,19,13,186,177,237,214,177,143,134,119,235,65,170,16,160,43,0,0,0,7,115,105,103,109,97,95,49,0,0,0,16,42,138,78,31,22,241,9,27,63,151,72,223,65,50,93,49,40,171,194,239,223,218,171,125,10,0,226,179,6,7,102,41,155,136,1,7,211,5,170,102,131,52,185,14,21,191,60,88,67,42,202,21,70,244,63,41,251,79,73,87,126,191,118,21,236,229,182,148,147,138,148,82,191,204,22,211,79,0,147,87,36,32,196,108,110,188,170,29,179,102,253,179,4,43,33,39,172,50,51,21,171,80,254,181,221,56,210,138,244,34,204,78,237,74,178,11,244,124,6,155,5,170,29,157,248,91,196,45,197,241,88,154,202,242,27,87,55,112,0,102,163,130,55,18,148,101,92,45,19,212,11,152,122,58,162,48,235,218,50,23,81,188,7,159,79,217,146,220,67,20,65,167,200,155,105,76,139,42,171,81,187,158,37,48,142,138,180,182,172,114,194,48,230,59,101,23,145,248,38,152,4,193,60,24,250,23,252,194,129,236,241,6,158,230,163,112,165,95,111,202,159,221,248,32,136,74,185,79,226,220,236,5,98,63,189,28,126,57,169,14,110,179,184,195,178,65,229,60,34,120,92,100,65,81,19,47,208,240,60,96,179,1,161,78,183,87,64,174,243,82,1,123,244,108,5,5,108,136,72,242,46,71,34,57,27,113,193,26,203,145,154,213,66,247,62,176,158,202,3,171,193,100,182,14,23,153,61,40,141,196,132,157,221,239,51,135,163,216,114,40,8,159,189,11,60,62,221,125,19,90,86,16,98,37,104,40,50,145,91,131,112,249,187,124,36,15,129,137,197,216,169,45,184,150,60,151,54,113,48,36,115,51,88,58,74,169,39,152,240,56,49,171,76,190,84,42,227,174,29,156,224,235,144,25,61,87,100,18,143,165,66,14,172,221,206,16,242,70,220,48,26,109,204,46,14,98,38,228,172,46,55,212,185,157,208,16,151,150,124,203,141,192,145,45,116,192,156,138,29,158,49,243,95,162,163,35,159,47,69,85,93,71,155,82,94,35,72,43,5,123,221,107,26,53,181,248,79,150,48,104,15,225,21,254,229,177,75,0,181,182,52,101,26,84,8,122,52,215,145,31,220,126,182,92,255,228,65,212,238,44,109,168,192,146,74,216,111,208,42,243,141,249,117,136,198,224,222,212,151,246,65,24,0,0,0,11,115,105,103,109,97,95,49,95,102,102,116,0,0,0,64,148,184,185,173,190,25,116,111,9,178,51,127,41,110,248,113,70,9,193,74,66,107,240,154,176,180,84,222,89,219,5,46,84,182,34,241,16,102,96,243,71,95,26,137,105,29,43,236,74,47,176,53,245,106,184,164,123,237,153,22,111,24,212,57,255,174,2,248,67,137,166,237,90,208,120,116,243,245,223,136,164,23,21,36,53,118,164,202,238,121,148,125,137,228,77,36,215,192,223,13,62,154,119,179,157,115,211,230,101,65,211,98,80,67,84,160,107,43,216,82,61,176,245,224,46,170,82,36,61,230,134,123,159,177,183,214,102,212,72,190,215,48,37,118,31,142,121,63,225,1,64,56,210,115,246,218,137,181,24,80,137,110,230,180,248,36,36,148,132,117,209,75,8,225,83,206,154,149,194,23,109,238,121,140,3,117,210,103,213,148,164,41,115,175,53,183,33,180,171,176,169,135,44,102,160,164,246,100,222,63,228,166,157,30,230,68,97,108,54,44,133,42,29,2,119,78,143,212,184,142,169,83,208,132,174,93,14,14,229,86,86,169,104,219,42,99,166,66,240,224,78,5,149,72,135,53,161,77,10,45,57,235,205,56,90,225,193,152,250,43,141,244,176,109,115,188,52,227,112,20,120,112,210,100,190,186,203,62,11,183,20,207,125,199,197,165,19,58,6,20,98,121,248,156,137,208,208,61,46,24,143,188,140,131,133,139,168,18,198,13,42,204,200,244,199,208,65,39,249,229,28,8,241,131,234,232,239,106,73,118,114,52,47,238,64,91,162,132,194,17,33,11,159,238,208,98,227,49,119,40,106,60,3,4,121,216,165,119,42,36,174,19,173,10,78,195,187,104,217,236,120,191,133,52,171,118,247,61,42,74,203,43,200,231,26,33,44,109,176,78,247,41,14,252,43,173,248,139,97,89,234,157,169,191,98,74,166,147,215,16,99,112,125,93,226,98,219,227,147,206,13,182,176,155,204,32,62,79,19,131,100,147,159,44,21,102,181,13,121,194,159,40,213,93,36,192,179,213,237,79,108,6,201,15,49,189,40,84,53,228,135,170,182,114,181,156,113,96,186,63,96,65,117,1,155,59,102,224,214,16,247,98,83,25,164,169,31,56,33,229,204,154,199,45,145,197,29,249,245,29,218,35,223,242,16,223,37,168,147,241,237,229,233,124,4,197,249,157,61,164,169,125,224,187,144,7,4,132,62,175,64,246,144,14,117,70,155,109,1,53,171,40,136,221,150,38,144,25,113,73,37,222,202,168,234,118,96,45,124,24,136,76,151,22,213,4,25,31,132,77,107,172,34,134,215,1,42,87,184,122,186,117,91,121,190,24,0,10,116,252,28,20,166,246,220,21,38,51,0,14,190,180,18,5,91,113,101,199,215,141,28,97,92,2,17,239,151,81,243,95,44,4,37,119,153,184,31,197,157,22,203,47,79,249,73,240,180,232,196,167,29,113,108,79,18,24,190,177,223,4,194,220,100,171,131,148,222,27,21,164,95,22,95,60,103,174,61,128,131,85,125,78,49,216,187,114,42,5,173,214,99,22,71,45,58,170,57,253,245,122,108,241,28,36,172,33,7,216,209,230,164,161,134,226,161,163,227,247,177,44,158,105,96,184,77,56,243,48,10,77,252,79,111,188,97,50,233,127,36,165,230,149,39,242,97,49,162,179,112,34,211,41,203,24,125,76,113,236,170,22,200,251,63,158,111,31,1,56,57,30,118,11,48,74,45,80,113,63,140,234,82,111,129,180,94,139,106,222,151,80,54,50,31,212,224,135,248,182,1,64,195,111,115,166,68,49,102,72,159,84,238,79,219,143,125,246,163,139,196,252,201,6,182,15,192,25,6,116,48,61,69,42,123,100,65,60,11,24,45,6,170,17,95,215,60,208,91,146,23,61,123,163,23,248,142,211,42,127,203,185,231,32,241,30,186,78,139,206,223,50,72,74,245,254,241,126,142,51,152,108,156,195,96,210,151,35,173,131,84,181,3,29,91,44,31,2,191,81,177,116,180,83,77,136,160,87,73,170,147,210,130,239,60,80,29,161,228,217,56,162,181,35,51,86,154,13,97,55,189,139,112,130,179,241,222,130,124,42,101,161,168,111,162,198,14,43,79,91,114,85,49,71,89,198,195,35,142,231,3,75,211,39,204,113,82,178,117,71,201,70,215,192,255,242,230,251,135,225,41,156,220,78,145,100,216,121,146,1,246,84,232,86,208,250,58,193,241,122,92,239,213,99,94,235,109,82,8,60,221,254,184,124,228,206,129,103,201,223,110,104,145,58,184,93,242,212,62,224,19,16,213,58,70,97,105,15,249,109,39,194,52,200,69,63,0,234,245,206,30,169,218,99,3,180,49,76,164,9,53,238,93,28,178,191,101,1,35,109,238,33,138,177,223,73,201,121,120,32,87,14,128,82,16,12,136,89,224,26,135,24,251,34,50,133,246,203,41,224,200,69,70,38,188,205,100,56,150,195,219,81,12,51,232,35,251,180,185,239,241,5,203,52,114,26,28,91,12,74,126,249,179,181,98,93,212,119,222,249,43,229,160,242,255,52,102,196,235,231,239,183,205,0,115,13,150,239,181,135,250,233,0,243,112,27,127,10,144,137,33,131,151,70,85,206,37,135,222,61,175,15,230,255,185,81,139,142,66,55,121,24,130,168,195,170,244,75,255,56,5,176,239,73,76,187,120,55,113,11,33,70,216,6,198,240,42,68,189,132,47,36,142,150,23,119,11,253,212,39,206,116,66,65,116,47,197,233,4,181,185,234,160,39,55,221,31,34,103,76,117,132,83,184,66,106,208,28,229,86,49,137,196,213,243,222,57,228,61,144,207,149,238,3,67,140,122,236,201,18,123,64,121,14,219,131,32,28,124,31,48,28,128,94,46,72,175,132,52,228,48,198,16,78,19,40,232,250,210,77,141,149,141,80,179,232,78,164,239,153,32,140,111,135,220,88,54,72,91,169,81,125,182,190,186,222,87,4,113,253,244,95,127,78,28,44,182,145,32,150,52,110,8,47,172,155,238,198,54,115,57,110,109,224,195,192,236,1,48,48,170,199,161,244,225,164,65,60,169,120,156,243,6,31,219,165,139,113,175,24,115,181,11,109,136,73,216,221,186,90,56,61,176,48,180,84,65,197,186,39,63,251,100,241,217,78,81,1,214,220,138,10,100,213,255,18,215,120,228,11,179,245,186,208,25,248,153,193,125,60,227,55,68,205,183,6,146,146,98,170,239,249,85,216,195,95,37,134,135,177,173,124,78,248,14,251,153,23,174,20,183,67,80,62,255,185,42,13,79,165,192,247,206,73,121,109,91,117,84,223,189,210,228,234,244,105,124,171,253,178,164,164,99,136,217,70,120,177,222,116,184,42,10,201,206,138,13,66,161,190,145,222,159,139,224,99,48,173,142,208,121,28,231,4,96,1,145,2,155,132,30,143,241,247,207,49,214,19,5,160,124,127,97,173,100,44,17,172,5,69,79,37,8,11,203,111,167,9,30,36,49,47,166,92,111,195,59,52,12,210,35,154,33,84,136,37,247,225,240,119,172,46,24,61,96,139,98,18,65,235,14,26,31,106,42,7,144,134,36,176,109,164,28,3,228,240,30,159,95,158,105,16,159,17,22,223,19,235,194,201,223,12,255,83,204,135,211,174,235,36,34,107,33,70,70,229,101,251,183,244,67,130,105,28,211,8,108,190,53,171,93,42,163,247,144,31,119,38,231,122,166,29,242,211,218,195,115,87,85,151,33,78,146,3,152,52,20,135,148,144,33,136,221,224,179,198,108,0,193,250,186,106,26,174,172,69,21,179,203,16,200,182,200,191,110,69,216,144,222,95,111,10,197,187,93,201,215,200,177,88,16,58,209,63,20,37,130,247,232,218,89,88,165,163,153,165,161,118,208,12,71,231,30,66,189,84,239,231,56,175,109,94,241,101,74,10,26,246,191,51,168,44,199,165,119,91,48,79,228,166,191,63,119,156,95,55,219,41,55,238,217,187,25,11,71,43,140,130,109,217,100,222,178,130,199,123,35,7,123,234,80,102,245,255,24,221,109,252,119,247,198,128,202,28,248,7,139,96,92,89,158,239,143,131,224,52,118,26,79,148,216,78,247,169,77,140,35,227,242,59,35,60,205,116,188,5,175,65,29,15,157,240,78,132,98,8,169,180,148,205,140,72,170,31,78,36,45,20,50,2,174,17,60,228,84,93,1,71,119,62,78,119,119,26,23,147,255,112,11,98,17,109,76,128,84,20,105,197,206,152,69,49,59,217,189,104,171,229,80,218,196,89,109,234,119,22,170,211,22,177,11,57,160,102,47,178,106,23,238,195,206,129,124,211,35,79,161,217,227,70,2,48,169,0,29,220,208,24,231,158,247,199,165,80,99,123,86,128,192,135,146,50,74,54,134,215,93,15,199,160,144,146,50,36,18,92,55,76,160,242,220,190,35,171,3,239,171,74,185,9,122,222,102,62,149,209,65,32,224,129,158,136,67,187,144,158,241,68,116,67,180,181,230,116,213,29,29,177,129,11,238,90,94,107,106,253,84,238,33,212,102,56,128,93,86,105,147,53,172,69,0,0,0,16,115,105,103,109,97,95,49,95,108,97,103,114,97,110,103,101,0,0,0,16,230,255,255,159,249,14,13,27,63,145,42,163,163,104,186,234,137,6,221,216,118,235,216,71,195,187,245,32,85,8,208,21,179,119,61,61,116,15,34,195,70,230,39,157,139,31,56,121,127,7,5,86,32,110,130,34,32,252,197,166,23,202,133,4,144,91,22,233,35,165,66,128,163,160,79,122,152,64,38,139,249,155,234,222,60,223,198,73,165,161,46,60,158,210,57,44,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,243,73,45,74,12,78,178,19,218,57,121,196,248,86,103,167,33,109,75,175,2,133,234,104,203,254,40,144,106,60,137,37,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,255,112,208,107,171,109,13,147,85,120,162,143,180,162,76,232,79,89,7,231,125,206,186,227,84,3,173,239,147,115,76,74,195,131,82,42,69,160,22,143,99,91,167,111,145,9,7,35,195,134,110,165,65,142,41,151,169,102,200,130,254,31,136,60,114,164,233,246,3,70,129,7,127,64,35,121,248,143,65,197,192,20,24,36,48,172,217,38,174,158,52,134,71,202,142,52,119,16,35,65,144,173,78,8,2,80,43,66,100,185,40,241,75,68,249,142,243,40,239,226,131,55,162,136,176,33,145,53,79,136,194,162,179,219,161,196,219,250,74,86,5,177,47,215,58,169,253,172,76,29,30,78,51,68,157,27,206,210,66,92,156,158,162,205,113,193,233,117,141,47,233,159,238,29,254,159,149,54,219,49,150,77,206,245,128,177,238,19,210,107,13,67,15,182,210,149,27,157,17,116,72,167,249,46,152,121,0,169,152,67,183,83,106,6,182,7,136,65,58,50,123,96,63,59,0,0,0,7,115,105,103,109,97,95,50,0,0,0,16,207,2,225,189,181,162,122,242,123,60,135,240,166,137,191,117,8,13,68,60,209,194,163,236,87,250,123,23,111,188,178,9,166,247,191,207,92,35,224,175,104,246,158,90,178,186,194,187,109,65,53,235,37,93,38,71,16,195,109,212,74,84,104,29,66,30,140,133,63,5,230,232,137,167,7,97,104,125,161,184,158,209,238,51,61,27,193,69,127,97,71,9,36,103,163,29,166,247,62,85,237,198,139,8,242,100,202,249,215,155,87,29,199,236,160,128,28,12,213,175,213,74,16,189,45,60,40,4,38,202,144,124,145,117,90,155,118,62,168,78,94,89,202,252,79,59,95,14,225,100,131,99,180,132,89,142,102,119,101,49,55,235,238,33,6,153,16,250,99,39,68,153,145,234,17,135,200,162,205,210,115,212,35,81,152,138,109,232,43,91,107,13,170,251,64,216,26,124,7,32,150,64,119,107,134,95,49,210,209,45,225,164,128,82,240,74,50,54,215,63,225,24,207,3,196,131,140,84,133,162,161,211,126,236,85,29,209,181,1,65,245,83,72,217,45,165,193,87,131,174,197,25,192,87,172,27,142,208,243,140,53,102,109,211,142,95,51,50,121,7,218,150,33,7,22,97,234,8,61,134,75,251,32,147,200,214,69,17,132,23,49,207,163,35,100,143,169,84,81,5,165,35,102,82,246,2,191,167,116,188,245,223,38,246,103,17,39,64,95,10,84,14,159,255,81,121,184,222,10,5,211,77,201,37,34,48,124,157,37,155,194,142,74,235,190,134,150,220,206,9,76,18,153,23,178,249,53,165,65,200,10,34,92,98,113,80,19,61,65,151,239,177,118,197,220,149,205,145,215,161,176,199,217,27,98,158,81,252,117,57,87,151,13,71,208,204,239,165,224,40,115,18,172,84,220,196,188,235,57,112,41,144,177,132,81,43,130,5,32,15,55,78,18,22,21,205,201,60,225,230,227,220,69,22,151,238,68,44,168,166,118,151,29,175,94,45,112,15,223,155,220,158,176,35,72,47,139,179,96,142,251,13,150,179,154,98,170,145,224,36,36,163,164,119,241,149,167,32,35,22,253,108,130,92,87,241,144,91,132,140,131,134,229,93,147,100,2,40,39,244,62,137,140,98,217,116,82,135,97,164,81,4,0,0,0,11,115,105,103,109,97,95,50,95,102,102,116,0,0,0,64,26,141,19,130,22,57,178,253,45,174,105,33,254,211,78,41,199,199,138,218,176,228,120,119,90,38,236,120,206,157,91,69,135,96,238,116,54,64,43,225,114,53,19,14,138,172,200,56,194,178,154,135,71,119,157,224,169,105,157,144,117,206,119,82,10,198,97,226,62,145,120,157,211,176,173,105,118,45,82,96,143,93,180,169,198,242,47,212,29,226,193,90,39,174,88,11,118,160,218,132,254,165,160,82,238,218,59,14,4,67,138,162,74,154,171,16,185,31,224,208,79,192,211,127,213,234,72,28,201,254,138,98,232,167,23,204,186,56,54,183,33,110,192,134,29,74,1,124,237,37,140,226,113,188,39,213,235,21,103,92,208,31,249,127,10,210,69,180,120,14,113,111,40,52,241,248,252,233,220,187,223,173,107,77,102,22,205,241,161,247,86,63,28,181,24,247,90,221,89,144,189,224,189,249,217,186,21,53,233,1,14,130,60,191,99,123,200,202,244,117,16,141,225,73,163,212,122,54,79,229,166,122,188,238,145,180,135,2,236,159,160,84,28,61,174,204,96,183,73,6,134,6,245,152,159,80,32,92,175,14,164,145,79,144,34,32,157,248,125,251,125,1,190,42,66,169,50,59,206,158,17,93,49,149,240,225,52,8,36,140,201,96,251,53,135,178,210,228,11,98,229,108,35,32,249,206,150,153,170,213,135,105,72,30,0,138,9,126,127,56,200,190,182,113,10,114,137,120,162,75,49,137,134,59,97,7,186,37,143,68,39,203,50,118,176,8,255,147,244,156,138,83,113,51,70,216,139,153,219,142,102,137,159,157,142,142,156,48,239,99,225,54,214,109,18,26,234,56,83,23,75,96,84,89,144,159,155,15,250,81,70,232,126,211,52,220,137,190,152,212,177,31,112,182,51,132,1,77,72,91,21,184,155,207,7,39,116,152,205,74,92,31,232,21,168,133,246,162,77,208,49,105,79,116,160,133,57,208,62,241,125,125,202,185,231,1,31,41,242,213,145,153,63,44,75,189,13,207,12,216,141,29,197,225,92,195,180,156,247,182,229,139,6,3,165,204,2,7,15,58,116,255,60,51,107,64,17,169,197,119,144,216,123,247,24,172,104,172,156,116,190,98,158,21,14,119,117,203,47,97,63,73,186,251,50,12,110,18,130,7,67,81,116,58,108,255,159,188,205,246,45,236,33,19,135,203,219,47,184,119,55,65,93,54,7,157,140,52,48,248,20,251,246,132,25,94,135,213,40,97,220,213,83,229,152,201,192,157,10,86,209,215,242,205,28,26,208,210,5,144,11,99,117,94,201,106,82,32,246,217,164,147,94,251,21,237,243,233,0,77,154,157,242,87,201,159,138,65,141,103,142,202,142,214,205,50,56,3,125,103,84,19,171,222,38,239,131,194,187,179,109,36,107,243,22,43,202,77,140,7,102,141,174,189,7,235,203,185,248,74,98,65,189,200,151,244,143,25,238,164,233,97,229,7,252,235,220,125,161,242,75,6,215,221,32,212,124,243,247,45,68,107,164,138,187,63,225,46,179,133,22,18,60,33,63,171,61,29,30,156,57,151,111,66,184,134,232,210,247,205,75,114,113,176,66,142,192,123,57,139,65,113,116,82,44,72,195,158,158,103,238,33,247,118,115,68,204,78,163,8,16,183,203,209,19,254,197,38,175,45,222,151,15,189,234,190,129,145,97,241,28,62,222,0,118,206,242,92,34,238,115,253,42,147,186,124,105,1,159,162,141,250,24,122,144,147,187,80,216,243,148,25,87,186,223,94,21,122,68,44,225,203,5,154,158,154,138,28,208,98,209,224,249,202,237,38,175,219,99,52,210,83,150,10,109,220,182,100,31,153,47,83,45,184,173,40,249,101,177,239,16,114,253,232,201,194,89,107,130,47,252,178,19,82,155,94,192,248,12,223,192,1,130,26,254,91,132,174,227,64,104,245,102,3,82,217,147,13,4,7,243,229,121,239,89,94,91,246,43,119,92,172,237,83,112,30,49,246,174,205,242,91,69,65,66,110,122,116,192,198,57,26,67,63,155,53,80,126,139,214,124,217,226,1,132,141,108,61,36,142,6,70,220,155,97,77,219,61,66,71,40,53,2,117,58,159,67,245,197,143,212,192,39,243,96,153,87,171,103,51,213,139,253,46,126,242,30,110,236,53,21,227,45,155,116,213,166,183,165,169,11,243,52,185,205,55,146,86,120,134,111,9,111,239,75,70,110,22,244,163,117,107,220,43,174,164,134,174,61,140,140,187,252,212,211,76,95,64,68,81,46,32,181,51,56,248,54,137,161,191,133,167,110,36,204,255,153,173,177,188,213,113,242,48,159,150,205,240,64,13,163,139,255,148,143,95,39,44,55,148,233,103,56,74,155,200,183,153,238,55,121,166,51,200,145,72,25,162,108,119,16,105,120,70,19,14,133,53,152,238,219,110,100,241,203,57,41,191,151,209,74,166,87,63,116,5,94,67,166,168,227,7,196,112,38,34,189,196,254,59,50,41,239,191,171,75,138,144,163,175,56,162,227,10,1,114,247,139,116,237,156,172,173,54,249,127,30,102,184,115,68,69,225,11,39,166,82,235,217,174,94,221,21,245,166,254,254,237,173,41,248,238,145,100,242,111,242,28,143,13,250,205,18,14,210,46,193,7,6,196,230,197,51,147,93,114,80,58,102,45,244,143,219,202,165,159,191,151,152,60,121,24,143,202,144,25,162,145,181,177,1,144,153,22,232,146,54,101,101,92,247,163,61,64,150,2,46,2,117,244,80,70,82,180,198,253,211,8,35,92,195,24,217,143,54,84,72,202,146,202,4,237,153,34,123,200,129,75,52,177,142,230,175,174,233,152,183,146,116,60,68,250,197,67,138,67,73,7,53,10,162,123,184,156,210,1,98,10,86,173,220,30,94,95,92,85,117,163,61,171,246,81,176,205,222,72,241,220,55,44,219,123,189,231,75,79,176,85,216,227,211,177,79,66,72,43,81,205,231,110,10,160,176,9,86,248,24,145,108,74,77,94,93,225,204,163,160,109,77,58,18,5,35,184,236,119,23,120,117,90,166,234,194,145,44,24,217,174,7,223,20,194,57,113,53,109,236,153,121,107,59,100,44,254,154,15,21,195,181,167,238,216,220,137,137,205,81,14,208,153,255,47,138,240,63,134,53,213,37,52,61,186,80,51,12,150,119,196,157,72,144,134,11,31,90,1,10,194,78,34,162,148,188,193,50,174,183,89,32,193,112,169,214,8,86,188,37,254,222,210,43,216,190,96,3,148,90,168,31,145,98,94,60,109,233,141,211,37,2,155,24,237,249,24,40,150,153,184,151,91,61,117,132,251,85,234,118,212,52,170,67,78,89,74,218,48,176,14,15,191,35,18,164,189,167,232,102,12,232,108,192,170,6,68,96,242,137,4,164,23,244,109,209,146,186,7,2,187,207,198,2,147,71,39,102,102,234,112,219,116,184,227,163,14,38,143,133,40,41,22,106,33,67,189,142,158,26,0,161,228,105,214,162,7,71,68,234,2,234,201,248,149,228,232,90,130,164,238,180,158,213,40,107,76,48,224,238,139,146,86,144,26,36,9,22,4,169,177,119,254,143,6,91,98,223,132,33,28,99,153,113,33,52,204,81,12,251,176,88,143,22,7,23,24,135,202,35,144,141,142,206,251,33,233,23,75,98,111,167,166,19,27,105,27,135,205,112,222,13,60,65,13,126,36,142,197,199,248,61,95,24,112,235,11,136,251,87,0,230,95,122,206,216,105,192,243,1,108,231,1,0,72,25,94,92,53,141,208,157,86,30,15,8,222,125,24,150,64,2,26,57,141,90,236,128,237,250,180,22,167,113,207,141,48,137,218,133,63,94,113,66,11,119,96,246,249,57,134,65,133,4,139,137,22,148,235,3,187,15,159,10,189,136,71,246,180,186,95,126,33,110,238,21,41,47,118,122,197,204,14,171,182,230,39,86,71,19,244,177,90,229,144,33,66,46,179,253,140,150,38,23,14,56,39,2,222,23,13,73,174,180,245,204,114,126,41,95,245,75,26,167,139,82,154,43,54,239,110,41,246,68,216,117,44,99,203,192,29,74,238,150,90,60,190,183,213,184,17,5,214,249,216,153,130,53,126,104,211,242,7,253,203,40,72,167,60,69,112,5,95,115,69,135,46,249,154,172,60,78,147,32,133,194,251,95,32,44,66,15,4,231,99,165,147,17,66,245,21,82,244,23,31,127,72,72,188,119,107,82,100,242,141,208,111,95,32,128,54,116,184,17,47,75,157,11,49,240,163,30,45,1,248,100,69,185,30,2,107,222,222,217,248,76,86,229,89,3,130,65,242,36,167,152,101,197,171,242,218,108,46,177,36,82,117,123,99,187,62,251,97,23,31,55,147,150,95,37,198,3,30,182,97,227,192,125,115,153,30,174,255,5,6,247,64,145,157,179,235,29,145,105,24,192,125,77,206,9,49,5,25,254,253,255,65,224,25,10,188,248,90,234,253,149,133,112,12,89,35,22,182,154,184,168,58,182,184,54,253,62,78,224,102,193,30,184,119,8,196,216,84,168,121,106,130,31,96,69,34,0,0,0,16,115,105,103,109,97,95,50,95,108,97,103,114,97,110,103,101,0,0,0,16,225,255,255,239,21,67,163,199,104,94,139,66,57,223,182,33,184,76,86,81,230,142,71,174,242,154,253,186,22,128,218,35,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,139,239,220,158,151,61,117,127,32,145,71,177,44,23,63,95,110,108,9,116,121,98,177,141,207,8,193,57,53,123,55,43,61,157,45,9,170,165,85,169,236,51,14,199,161,1,119,114,196,208,177,48,72,242,150,184,12,20,142,244,0,91,87,17,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,7,0,0,144,11,183,45,219,248,19,18,84,251,89,107,25,140,106,137,138,253,231,49,10,36,97,91,40,36,37,190,82,33,0,0,240,17,168,32,192,185,130,231,176,87,241,176,46,2,100,172,177,134,252,88,194,96,165,101,7,207,28,238,60,244,52,18,139,77,109,21,4,179,69,26,122,139,211,19,112,3,84,155,248,119,32,116,104,132,175,5,134,191,28,192,32,202,146,156,35,118,85,7,120,27,150,165,205,108,166,31,230,253,231,161,179,183,106,62,90,127,224,241,39,186,23,179,60,53,54,144,34,48,146,28,210,164,15,17,253,111,70,68,17,242,173,241,44,96,0,175,40,150,248,14,57,39,107,212,20,78,82,175,149,237,151,31,214,51,93,57,234,138,21,200,236,169,155,87,67,49,112,26,213,194,244,50,69,52,32,224,25,130,169,204,189,78,168,55,116,47,241,241,103,142,74,27,202,223,50,104,211,20,31,196,11,137,179,83,159,252,91,199,25,6,25,45,100,193,5,69,182,91,74,53,69,246,35,191,46,189,254,63,240,167,225,37,123,138,182,127,28,105,68,233,44,70,142,29,61,166,69,238,240,147,17,65,138,142,214,254,131,41,152,13,27,131,195,252,140,215,38,43,149,41,90,71,54,0,0,0,7,115,105,103,109,97,95,51,0,0,0,16,66,229,26,140,193,165,55,119,15,12,248,174,63,135,26,175,80,19,58,243,40,169,191,223,164,134,73,168,176,59,157,2,41,171,35,235,69,101,127,197,69,244,81,73,63,185,245,150,95,138,250,14,115,109,193,123,161,161,227,167,40,98,248,26,25,223,69,20,172,77,143,172,36,24,106,8,195,118,199,159,2,31,80,156,155,199,128,196,124,218,219,128,13,43,164,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,52,102,152,102,110,80,39,205,200,21,113,241,44,110,114,162,202,98,215,184,74,145,200,227,222,107,157,167,234,124,100,25,60,233,187,48,141,189,81,177,166,163,210,90,38,51,8,107,89,76,51,209,155,219,235,64,50,133,147,255,14,19,23,3,186,250,43,233,140,91,221,35,87,237,145,194,251,236,164,166,248,4,77,115,38,194,33,130,12,81,36,69,167,36,53,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,230,217,194,233,70,125,59,175,108,61,203,137,75,243,39,202,7,209,220,145,103,152,150,30,115,160,178,188,216,1,153,28,129,199,23,66,244,67,106,216,29,124,11,245,201,162,243,159,134,255,60,77,156,187,74,106,106,78,194,120,111,237,11,3,193,97,220,85,115,122,193,180,129,127,69,178,66,223,93,55,95,173,155,225,64,130,201,173,190,62,139,220,78,52,238,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,136,22,65,247,231,78,29,193,184,81,69,154,109,191,91,238,108,194,245,64,231,220,177,39,113,183,84,219,104,134,176,14,248,163,8,194,146,251,193,172,170,248,46,60,48,151,41,7,97,109,103,159,23,185,94,94,55,69,47,247,22,50,146,49,139,136,250,168,176,250,191,145,184,27,113,43,178,205,192,240,44,46,103,20,94,21,180,42,205,43,27,25,120,38,26,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,11,115,105,103,109,97,95,51,95,102,102,116,0,0,0,64,191,253,180,148,17,83,17,218,184,24,171,24,59,180,212,99,81,211,86,128,62,212,212,32,94,228,8,19,60,97,136,33,96,43,188,198,181,253,213,136,98,98,195,1,56,235,243,226,77,62,219,48,103,219,108,76,187,182,65,124,62,28,29,88,112,241,239,105,239,73,221,94,253,41,211,235,143,44,174,93,121,95,132,35,156,17,187,244,141,72,0,112,37,46,181,94,54,136,168,51,99,243,72,0,217,218,230,181,251,143,64,44,217,115,29,22,196,120,71,153,174,96,247,16,246,130,221,45,57,171,32,4,199,135,199,161,103,106,205,159,96,6,58,177,79,110,250,213,58,227,246,182,68,96,27,89,49,117,104,86,234,188,195,80,96,68,94,181,59,174,247,254,101,3,25,47,88,18,135,241,4,226,11,205,30,148,221,125,169,89,178,65,140,72,242,253,59,202,230,184,228,91,61,239,17,207,104,171,91,166,199,245,0,238,12,56,78,36,129,220,92,63,208,40,47,241,44,8,60,180,112,101,94,80,169,211,139,127,70,55,125,254,105,117,146,76,73,13,132,30,133,230,202,219,228,90,77,145,33,151,131,228,44,139,68,183,187,68,133,227,31,223,239,47,46,94,114,96,231,21,59,68,177,152,164,241,78,24,130,84,224,48,2,58,108,134,23,207,74,62,222,254,213,175,255,108,120,128,112,30,137,101,184,88,148,4,28,118,75,43,173,243,208,61,170,11,6,134,146,69,205,59,58,247,117,172,223,177,43,207,166,119,89,35,173,174,235,3,56,125,83,80,87,184,74,177,156,240,241,55,143,116,95,251,197,235,183,144,246,61,169,65,159,179,90,160,148,92,67,130,107,95,132,7,102,229,15,235,163,112,221,156,166,125,235,58,160,221,240,7,91,166,25,187,4,74,252,91,206,165,72,159,46,95,174,38,87,198,46,81,210,101,217,93,84,225,70,200,190,169,137,114,206,39,81,215,133,45,15,153,52,56,126,82,161,220,65,69,25,239,32,195,130,164,18,244,31,140,20,165,113,53,42,178,241,154,37,54,93,240,200,214,105,192,65,29,174,109,180,38,26,14,174,255,101,97,109,234,5,76,120,51,46,156,45,79,81,50,143,121,91,89,109,22,123,62,244,63,62,115,253,61,147,199,150,169,148,125,108,172,254,251,196,238,200,241,12,253,81,201,46,78,4,59,154,233,185,128,6,246,219,238,98,43,251,160,252,238,20,120,157,146,157,232,1,47,173,218,148,220,123,121,135,84,114,69,43,98,144,31,146,113,51,104,160,78,210,192,84,148,137,240,204,252,238,77,240,200,231,226,164,243,92,109,82,42,47,66,12,49,84,174,127,121,137,123,237,81,198,252,220,147,247,165,67,132,146,180,239,78,249,145,219,244,200,13,220,85,43,126,81,216,88,79,156,211,22,129,243,38,59,133,118,210,150,28,215,248,5,118,190,66,176,18,6,108,198,3,13,248,223,66,178,19,240,128,198,78,21,221,31,3,87,10,49,21,58,58,222,249,250,108,210,215,48,131,221,60,237,160,161,193,128,155,144,175,2,61,211,83,242,157,66,67,40,13,175,100,25,51,176,249,224,183,209,154,120,123,253,185,180,20,43,46,17,141,180,81,223,120,32,180,95,173,221,32,230,141,13,154,103,222,218,12,55,69,156,176,67,81,60,65,250,194,53,78,11,254,192,248,23,46,205,122,120,39,116,41,17,155,208,247,250,171,184,244,47,10,87,54,16,182,111,134,110,198,200,225,27,82,64,255,72,123,122,251,209,101,196,63,225,77,215,136,21,221,94,186,158,116,67,225,84,37,112,21,83,105,160,249,7,140,85,12,80,248,108,252,151,49,199,5,40,237,21,179,215,127,159,119,227,167,149,205,160,33,43,176,193,230,124,248,175,129,203,11,149,129,204,18,37,208,119,21,28,248,254,209,35,53,147,68,172,35,244,26,116,235,7,225,117,248,118,131,148,155,25,171,96,68,17,108,228,173,26,11,171,99,69,229,167,215,195,69,248,93,71,243,197,161,226,157,219,3,151,240,241,52,36,135,158,145,121,24,234,185,121,84,180,59,126,198,27,179,30,198,233,255,182,17,47,218,197,37,30,148,58,35,154,94,185,226,28,189,242,173,104,120,89,35,231,94,95,64,32,26,220,213,167,177,209,64,11,72,76,59,1,254,99,37,12,116,70,193,26,100,24,187,231,11,54,31,82,231,134,188,4,238,25,192,49,110,208,36,191,178,89,192,117,231,57,181,176,133,5,143,99,155,143,228,208,144,187,52,221,155,187,46,84,223,141,242,230,226,207,44,210,165,0,100,20,91,81,53,94,150,224,241,99,20,238,175,92,218,62,66,92,52,200,14,252,200,110,75,26,48,33,14,195,187,166,39,193,255,107,236,38,185,5,255,198,120,23,56,0,127,59,3,78,136,22,114,237,213,87,100,122,88,207,117,69,156,6,110,225,61,128,85,53,129,249,236,203,69,179,85,167,229,163,39,22,214,25,144,43,42,179,239,210,27,130,61,202,26,222,242,165,193,59,30,195,164,143,62,88,171,143,143,161,87,209,40,125,38,90,187,31,183,7,126,166,243,186,138,29,56,36,57,194,144,10,148,228,75,24,104,24,25,229,110,171,96,228,81,12,239,254,114,22,121,172,106,156,152,42,119,7,35,11,184,234,200,8,171,126,176,36,188,159,88,48,120,234,228,6,25,182,203,128,36,253,98,8,142,153,5,30,141,240,135,45,236,128,82,173,134,124,22,167,197,220,212,169,104,53,12,162,25,175,155,173,73,16,165,2,19,133,38,22,172,37,33,240,72,232,92,141,195,162,12,173,238,90,133,241,71,79,119,17,51,81,32,213,118,166,19,71,140,252,131,45,84,157,125,138,58,0,29,168,95,63,25,223,22,243,102,55,18,92,131,207,80,118,162,120,133,185,145,158,220,142,102,235,140,121,73,94,224,229,239,148,221,246,59,105,56,114,144,229,113,141,143,93,58,105,200,199,92,25,38,14,112,22,137,157,20,27,83,202,158,147,151,118,27,143,172,248,195,155,122,228,170,231,231,186,77,131,132,180,2,129,237,30,146,155,10,254,55,246,106,9,161,102,20,189,175,249,40,15,146,202,3,139,76,102,181,218,72,212,214,147,99,202,233,210,214,252,184,255,127,159,98,77,250,246,186,239,117,112,151,0,190,22,225,241,134,60,85,195,18,177,62,28,140,203,30,115,53,229,166,213,248,35,29,99,71,151,147,123,23,144,238,120,58,30,204,241,13,177,135,65,45,209,35,48,183,47,8,203,246,253,185,40,82,106,22,141,138,73,176,217,151,37,5,96,96,5,101,9,107,55,108,147,12,38,249,131,200,46,192,122,31,15,69,238,234,171,37,81,89,18,220,253,240,234,77,206,63,189,56,129,185,196,208,9,46,39,36,33,143,153,19,213,75,237,184,162,171,107,149,48,205,64,252,244,233,229,104,111,239,195,42,199,121,175,105,143,6,83,255,194,118,199,5,38,201,250,72,148,81,46,169,129,224,237,91,207,39,136,33,15,184,75,208,74,160,221,140,14,96,164,235,222,137,49,157,217,89,62,218,3,186,55,102,166,91,1,149,13,130,82,214,185,99,180,170,204,217,76,220,112,4,218,185,140,172,195,139,66,134,88,20,11,123,102,230,32,47,83,82,110,174,208,126,94,253,209,176,121,160,102,190,63,83,29,229,94,140,239,12,136,96,197,61,254,24,189,76,145,67,163,176,250,220,140,84,144,206,206,69,212,211,6,187,185,0,107,96,109,205,247,98,59,15,145,169,52,38,133,145,40,97,181,198,166,153,166,112,51,124,177,186,26,47,31,90,66,26,160,88,50,50,255,38,3,20,13,114,126,39,202,11,122,213,250,178,225,88,142,25,113,118,82,161,69,227,47,211,50,47,66,232,80,6,122,54,102,96,192,97,127,144,158,234,243,142,94,35,195,230,123,254,84,43,173,131,147,68,168,175,118,47,97,51,16,129,242,179,111,170,64,252,81,188,1,240,31,206,224,134,192,63,28,42,140,23,227,219,144,221,70,170,93,62,119,26,125,108,24,113,250,42,45,90,246,170,66,139,19,62,86,102,243,171,185,122,219,92,112,35,78,31,143,26,196,20,62,236,53,137,98,186,13,248,172,75,13,23,39,56,202,59,229,22,4,163,202,151,79,161,65,131,228,18,29,23,17,85,100,155,3,60,76,141,1,106,27,140,68,75,133,203,93,185,43,149,183,146,184,22,83,178,72,238,213,15,152,148,166,96,213,242,116,12,1,20,182,123,54,80,184,247,137,191,27,234,65,99,219,26,38,129,153,62,92,45,71,245,198,15,68,24,98,157,146,144,125,196,157,182,252,27,48,92,135,248,160,100,108,232,151,164,234,119,248,168,189,162,232,183,183,172,193,87,163,172,138,156,117,98,220,148,216,248,69,7,179,255,55,51,135,25,71,166,218,100,45,71,45,122,217,199,94,155,0,5,82,125,142,132,184,71,187,142,96,190,11,48,122,118,101,172,171,13,199,125,218,193,83,62,111,101,131,108,198,49,114,27,0,0,0,16,115,105,103,109,97,95,51,95,108,97,103,114,97,110,103,101,0,0,0,16,219,255,255,79,158,129,87,48,1,187,50,104,134,109,127,48,137,58,78,72,159,236,101,92,248,217,211,115,101,169,128,1,63,124,173,181,226,74,173,248,190,133,203,131,255,198,96,45,247,41,148,93,43,253,118,217,169,217,154,63,231,124,64,36,204,201,111,205,99,99,197,113,236,96,168,124,216,161,239,22,107,170,143,84,86,69,161,143,147,167,34,168,75,227,143,27,234,128,156,191,131,194,134,234,16,193,212,125,120,82,212,220,163,49,98,15,99,120,142,178,138,170,28,94,162,235,58,19,199,140,10,184,173,237,232,228,123,84,156,254,133,48,130,169,213,228,57,35,11,15,248,141,178,124,29,77,195,135,42,12,102,97,93,18,182,41,218,17,149,177,137,83,162,178,105,176,36,122,39,209,214,61,210,122,210,142,116,174,19,49,187,29,188,113,226,162,129,165,213,150,142,207,49,105,2,250,104,204,144,24,245,231,233,199,163,227,123,25,56,45,188,66,129,42,160,5,61,87,114,86,118,54,32,98,177,254,98,215,207,202,25,66,137,67,130,70,216,68,191,214,38,139,171,30,203,20,38,0,0,160,245,115,138,19,144,181,134,17,194,122,180,247,211,29,51,57,23,89,234,91,49,198,93,109,13,165,227,46,242,165,226,6,101,229,64,83,119,77,3,144,247,141,44,48,246,84,33,94,63,169,222,147,175,18,129,148,224,65,168,58,139,22,239,109,147,10,90,127,92,16,218,73,109,223,190,184,6,190,13,86,140,109,199,128,213,6,87,232,210,154,114,24,166,218,121,41,160,226,187,149,146,223,122,252,31,238,81,174,85,106,136,207,217,102,56,151,26,247,17,222,251,230,254,24,196,98,210,230,233,79,140,154,164,60,171,178,166,230,188,181,152,135,207,80,110,83,185,255,28,140,163,236,113,243,12,31,208,49,143,112,110,142,247,244,121,123,131,68,75,19,23,121,189,131,228,254,170,246,145,161,146,87,191,217,87,224,165,69,161,183,207,65,159,209,76,232,87,9,101,107,156,89,137,166,245,220,153,160,135,233,163,184,225,199,60,79,200,97,146,63,84,68,240,226,45,237,29,33,75,72,129,63,222,103,203,4,101,131,67,237,54,132,98,220,53,200,51,230,49,108,34,65,0,0,0,7,115,105,103,109,97,95,52,0,0,0,16,181,39,240,95,21,56,61,69,99,238,239,38,185,165,36,151,218,130,113,126,54,89,43,10,163,14,75,168,227,174,236,15,220,158,20,65,138,19,204,144,233,5,219,91,135,172,158,139,78,115,79,51,2,74,28,119,109,192,129,46,223,103,6,31,41,51,223,168,170,78,177,139,158,203,147,150,123,201,43,151,186,24,134,149,46,130,120,190,104,101,55,249,211,145,130,9,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,2,110,123,180,112,213,182,160,84,27,197,140,158,234,190,77,80,38,237,6,220,214,203,189,205,93,213,160,93,112,106,29,20,250,147,54,153,97,201,142,254,37,65,46,173,166,70,0,79,95,188,150,71,129,216,251,191,161,165,65,172,192,134,45,22,48,157,67,219,162,231,236,184,46,215,253,120,74,162,210,82,8,216,111,103,212,250,34,133,218,54,97,25,41,194,49,1,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,2,188,38,183,111,117,33,158,248,149,111,65,250,34,171,52,249,47,42,194,55,184,200,143,193,122,103,170,96,106,143,238,10,231,241,133,164,163,202,79,0,220,150,230,178,155,72,91,119,86,84,120,253,118,133,176,54,180,140,63,78,227,12,104,35,157,184,204,54,232,199,94,219,184,9,85,48,225,199,198,145,5,232,202,111,28,133,230,105,228,228,142,37,72,26,102,17,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,2,160,94,32,100,39,186,161,144,97,134,151,56,169,113,128,22,178,19,197,55,69,155,175,207,15,95,81,194,157,232,220,35,212,79,213,175,229,203,16,2,146,236,158,184,144,74,182,159,77,236,89,179,108,50,101,173,198,115,61,240,5,147,162,48,250,194,58,239,17,13,158,74,54,129,177,17,163,247,222,39,71,45,202,193,255,12,218,137,76,245,153,207,165,35,252,44,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,2,0,0,0,11,115,105,103,109,97,95,52,95,102,102,116,0,0,0,64,58,95,86,149,157,135,226,187,87,128,241,147,65,190,235,8,184,188,236,164,60,225,87,16,85,170,44,53,36,254,214,23,64,161,158,54,39,121,97,208,165,206,80,176,197,30,80,51,123,145,29,222,4,182,104,191,125,86,119,134,92,244,88,17,117,169,219,98,53,166,13,195,16,165,125,200,81,220,212,148,89,93,183,231,131,143,173,205,195,244,139,222,61,23,220,79,103,236,4,11,25,128,151,75,219,27,5,97,126,237,70,206,209,11,74,30,236,135,174,130,88,167,200,16,29,75,191,31,186,26,103,217,81,87,191,159,183,108,74,6,17,154,196,158,41,202,90,59,127,195,95,218,117,128,144,128,41,14,116,4,213,255,92,100,123,66,106,22,226,212,200,235,34,82,97,132,134,244,38,109,70,235,78,35,150,147,182,56,66,238,46,25,127,21,201,216,153,116,156,146,18,107,78,101,130,194,236,35,18,25,163,195,50,93,62,159,168,178,204,11,212,13,164,87,112,186,96,211,32,74,217,228,71,52,62,122,146,143,203,143,77,254,167,10,45,110,24,254,39,131,14,90,255,115,151,85,195,127,220,48,126,61,31,157,87,213,30,82,153,203,183,147,48,213,100,51,178,11,139,254,111,192,92,90,116,103,6,85,47,241,153,179,115,58,197,226,49,24,199,145,109,118,145,136,184,171,235,180,33,136,21,245,238,106,168,53,60,101,179,42,117,35,244,205,17,180,184,54,201,186,218,172,221,137,200,216,49,131,165,90,74,71,158,165,120,58,18,75,106,61,100,87,50,40,186,160,120,216,215,174,63,22,84,176,204,188,241,198,225,73,168,153,183,187,247,45,70,69,166,230,77,96,97,50,141,231,127,216,166,34,151,206,171,34,112,121,150,139,116,143,156,214,60,127,59,255,237,129,15,97,138,227,192,66,169,75,88,189,165,44,97,221,242,107,115,83,243,245,53,158,191,250,248,113,64,213,56,226,153,15,64,151,108,45,242,94,244,87,193,200,19,71,248,232,0,205,125,72,9,7,192,135,192,253,219,217,75,175,61,18,109,85,228,45,27,28,85,94,231,45,27,213,107,172,183,135,105,252,65,164,171,168,157,222,200,216,107,109,47,90,211,30,101,13,119,85,172,72,68,4,135,44,228,70,236,1,255,183,116,37,9,47,10,226,191,28,251,184,245,88,40,29,79,220,68,195,158,9,240,31,83,142,193,46,143,34,196,53,134,21,133,92,191,167,129,48,229,170,133,102,113,19,7,253,146,137,126,195,104,222,232,166,69,47,62,7,229,232,217,250,237,143,83,38,20,130,70,121,77,215,142,78,31,152,197,41,224,244,61,158,46,116,1,226,169,208,48,3,174,115,103,166,27,39,37,172,115,60,91,184,221,179,157,227,98,42,67,123,27,83,251,146,30,96,61,96,101,36,45,80,134,63,19,109,253,176,105,186,100,227,178,205,28,26,249,54,122,195,227,108,130,250,185,228,143,205,55,4,229,82,209,19,146,216,96,204,190,26,84,112,32,115,206,225,24,53,239,91,37,119,92,234,86,175,55,196,179,163,185,135,182,137,223,81,174,231,157,167,236,4,196,183,225,149,52,199,221,206,114,143,48,204,146,8,18,114,179,98,176,37,192,79,134,89,118,68,219,203,187,28,135,39,109,23,81,78,165,216,152,7,92,130,78,83,137,19,51,136,152,17,187,58,251,90,221,49,44,40,98,57,182,158,222,187,5,4,13,183,108,202,217,95,142,156,20,32,235,134,143,252,144,66,224,83,249,29,127,156,140,26,19,88,229,97,153,101,143,142,50,174,186,142,146,7,107,75,207,199,175,176,137,100,173,71,201,46,45,125,162,49,112,19,149,248,94,225,26,198,72,194,243,223,24,191,71,113,146,35,218,109,110,67,176,119,108,165,9,157,57,161,128,3,194,85,109,22,153,230,70,169,43,17,62,44,130,226,16,220,123,50,246,184,11,185,180,162,211,14,97,206,124,82,18,197,22,42,68,204,27,142,197,196,245,147,155,156,233,191,189,31,243,49,198,150,249,4,14,135,28,80,74,246,120,45,168,249,247,47,90,97,121,29,4,159,255,121,240,152,242,194,220,23,74,16,169,60,49,147,253,156,127,134,198,117,9,43,98,240,187,86,41,155,138,84,238,50,204,79,111,15,192,28,249,75,126,118,52,30,193,221,88,226,85,185,131,149,103,185,3,42,197,24,209,194,179,246,246,94,184,143,52,28,103,117,88,112,171,129,43,52,1,84,205,28,99,36,155,66,75,104,12,21,116,64,114,210,219,129,186,65,208,26,184,230,250,225,0,43,77,22,35,254,140,133,123,228,84,200,65,73,38,151,244,161,186,20,194,252,247,45,108,86,23,168,24,237,50,97,112,106,56,42,48,235,139,43,163,37,131,160,239,222,237,154,70,235,19,9,169,70,48,235,109,173,147,235,52,162,53,36,180,74,210,65,200,127,60,148,79,217,105,137,107,65,146,23,234,88,45,67,249,42,147,199,175,190,74,71,216,39,125,71,93,201,42,165,167,27,36,82,207,34,26,231,189,84,106,230,171,41,255,82,70,249,64,115,177,171,21,101,109,207,15,241,92,111,143,208,114,184,194,63,106,8,238,228,113,38,143,131,243,153,173,44,145,90,206,94,176,237,35,4,89,110,31,248,171,221,165,95,186,68,77,126,156,14,246,9,174,149,162,104,254,183,139,86,21,137,178,54,212,211,249,122,201,106,238,112,250,131,23,159,103,142,103,228,202,74,76,18,0,130,54,179,93,31,133,37,236,128,231,215,179,120,32,101,12,64,170,148,182,2,27,146,164,185,183,22,140,216,248,98,3,26,74,129,136,203,67,35,91,118,98,92,230,96,234,161,41,181,240,239,224,215,244,102,108,99,176,94,129,47,120,143,241,198,7,214,92,190,157,17,203,21,24,171,57,174,9,67,5,67,202,34,116,17,8,172,139,224,53,161,226,74,84,25,38,50,223,121,176,145,124,10,1,224,218,187,183,56,238,147,0,80,5,3,118,229,206,214,51,77,57,128,109,199,163,232,84,122,21,67,82,6,175,9,130,193,220,158,125,223,173,197,169,173,197,248,245,205,132,105,86,164,61,57,154,80,116,121,16,90,34,171,57,158,218,81,121,59,160,41,228,111,93,186,185,235,190,102,109,98,15,19,83,177,214,221,239,119,202,130,28,29,205,87,250,29,246,37,8,231,24,234,90,219,168,255,27,127,175,164,155,220,174,145,10,55,58,222,20,206,124,46,16,163,247,148,136,15,20,81,237,122,122,214,85,31,239,209,98,18,98,136,17,155,104,192,220,38,170,85,45,79,36,157,15,224,3,250,231,15,191,0,177,198,229,102,132,238,76,16,195,199,2,125,128,65,234,7,168,218,170,201,174,101,227,113,150,139,235,108,218,197,159,12,2,145,187,3,190,63,13,49,96,112,91,214,116,154,30,112,144,237,44,54,43,91,141,167,168,212,85,8,30,241,16,4,193,40,202,240,19,242,83,12,155,206,130,115,211,72,180,114,110,230,81,241,239,159,29,9,44,147,136,34,65,226,102,10,15,50,221,171,220,68,71,152,188,42,43,153,12,163,228,61,102,234,188,179,23,187,245,194,207,53,149,196,147,191,177,92,126,115,33,171,127,215,133,72,62,164,187,239,156,33,138,27,55,139,44,112,238,189,182,151,222,135,31,143,143,199,99,84,192,171,94,133,248,118,183,249,226,130,81,217,244,16,173,27,78,238,58,95,96,178,124,103,66,206,108,138,181,78,144,1,98,235,135,237,32,99,134,16,77,95,4,215,188,160,152,78,58,24,239,68,215,236,221,158,53,11,245,49,142,40,86,36,90,66,48,225,171,112,233,175,246,222,233,170,35,229,2,61,139,5,15,141,73,137,188,175,238,30,218,17,79,90,53,43,131,143,125,130,254,219,26,49,117,62,34,251,53,196,42,216,97,185,152,134,25,124,242,161,56,3,66,248,216,33,235,33,220,248,94,36,78,136,85,108,75,170,178,179,168,123,215,219,70,48,1,176,195,148,189,14,116,208,63,151,156,35,164,1,157,219,46,116,118,138,115,72,233,216,28,172,230,103,33,138,157,70,109,37,248,124,59,49,83,203,137,186,100,226,10,80,13,239,182,54,139,31,195,61,53,15,187,206,186,252,81,8,255,12,157,34,216,81,122,125,1,75,138,150,214,139,64,12,199,23,237,242,189,145,138,240,200,177,151,47,1,195,39,197,23,222,56,199,211,68,54,0,58,134,155,137,178,161,162,19,216,90,126,98,221,28,165,56,219,73,95,28,144,107,171,17,100,98,6,0,240,244,108,113,102,118,15,246,89,27,209,86,74,51,203,237,102,99,127,155,76,182,251,144,202,97,33,152,195,225,120,112,123,175,12,205,89,101,22,54,55,75,68,56,191,221,247,157,36,16,124,230,245,137,80,242,248,86,1,82,254,14,100,62,205,255,34,109,95,210,63,192,219,78,60,89,145,111,61,173,88,56,177,85,89,221,29,154,62,154,57,219,203,174,194,22,1,60,64,67,88,149,26,114,41,99,172,45,0,0,0,16,115,105,103,109,97,95,52,95,108,97,103,114,97,110,103,101,0,0,0,16,18,233,76,93,171,141,87,229,230,139,134,77,45,136,34,96,209,90,91,63,102,89,87,177,120,202,102,31,228,53,56,12,180,101,190,71,79,64,83,121,98,117,241,57,146,231,161,116,240,107,134,7,159,143,175,88,212,210,67,87,20,226,205,11,91,37,134,198,243,18,38,174,254,144,62,125,40,250,225,121,7,238,248,177,220,222,23,33,15,169,31,3,119,103,101,23,179,173,80,90,166,93,194,109,93,19,128,143,189,210,107,59,179,188,41,62,133,213,53,227,102,171,254,155,62,46,132,22,229,69,174,172,45,108,238,85,239,75,23,76,209,220,136,80,124,52,35,90,226,2,145,241,224,228,105,143,165,134,168,31,198,169,141,192,170,77,111,109,206,24,222,97,78,65,20,50,140,245,14,178,5,154,126,122,26,103,105,64,190,29,141,14,174,187,15,253,249,253,165,102,215,152,241,179,178,104,156,75,85,45,191,21,54,7,62,148,29,120,47,220,179,48,166,31,27,0,0,80,154,230,212,40,82,223,142,214,164,127,121,61,211,81,164,168,63,90,119,112,102,228,59,192,29,70,148,26,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,239,22,179,146,232,103,138,94,170,228,50,44,27,96,17,200,139,253,37,66,80,236,248,6,177,213,202,193,142,24,44,36,77,154,65,168,68,181,142,202,46,251,199,63,182,0,146,179,108,236,250,121,23,182,160,95,85,205,237,137,94,108,150,36,23,127,99,48,16,51,91,89,128,175,228,251,207,149,95,75,185,38,31,114,83,205,193,5,159,245,20,131,208,98,41,29,58,115,245,55,230,7,249,94,21,28,29,123,194,183,177,126,135,115,71,94,171,54,88,42,119,35,20,148,175,198,57,36,28,186,81,67,102,137,243,237,161,36,162,45,119,11,171,215,224,35,94,39,212,66,191,198,72,187,199,81,205,199,187,16,59,86,114,47,233,167,114,214,194,87,219,23,250,166,31,246,208,98,114,207,176,171,209,61,15,57,200,160,180,48,215,33,97,250,194,152,33,159,107,13,113,14,8,123,229,16,100,93,67,22,248,61,52,255,119,115,106,201,10,86,199,47,153,27,0,0,0,13,116,97,98,108,101,95,118,97,108,117,101,95,49,0,0,0,16,253,255,255,47,68,31,90,52,76,174,211,146,38,71,100,135,232,246,123,123,220,46,15,215,130,31,107,92,167,20,211,46,66,171,35,91,184,96,144,102,117,242,109,44,83,104,7,132,120,43,156,180,69,60,152,123,180,69,188,165,96,11,196,4,47,29,66,12,197,122,137,233,42,72,106,132,45,155,251,23,98,201,206,229,114,44,5,245,52,187,103,183,16,74,23,15,172,196,208,238,218,251,49,160,122,184,187,91,114,176,92,40,251,244,47,167,109,39,85,247,59,249,34,173,246,93,43,33,168,179,37,187,204,112,159,14,180,80,135,102,79,87,98,125,59,187,166,118,109,248,48,60,145,94,4,51,203,136,80,20,199,25,238,33,198,3,67,5,34,1,41,17,223,5,17,121,229,199,164,33,225,6,30,100,55,181,249,229,103,146,175,39,13,9,198,133,18,154,84,111,120,253,131,251,29,58,105,24,202,71,158,93,60,209,69,184,50,59,112,51,8,140,126,46,118,247,161,59,36,61,205,61,63,143,236,116,40,135,128,243,193,59,24,99,84,210,155,32,14,87,210,51,179,217,13,16,5,0,0,176,227,203,105,83,214,50,159,96,106,137,3,201,209,185,134,135,144,92,145,153,208,32,248,101,62,136,245,49,191,84,220,148,219,148,81,221,27,126,75,77,245,127,44,164,228,44,229,204,112,9,184,60,117,90,117,59,18,67,160,43,210,226,189,227,206,122,88,90,102,40,79,245,26,77,56,16,251,142,178,155,67,25,75,195,244,228,201,41,98,4,77,33,85,59,47,1,185,249,175,163,22,184,253,29,214,55,215,255,97,99,81,218,72,30,251,192,237,166,14,52,124,240,56,15,89,76,218,52,199,132,66,53,221,31,50,19,249,144,209,170,33,157,218,10,73,77,31,124,152,65,45,174,167,197,19,28,58,230,17,206,205,241,158,62,111,111,144,104,105,226,34,175,119,144,220,95,213,62,50,84,242,234,55,251,10,188,180,8,245,246,57,90,21,81,111,24,170,227,238,247,114,150,254,55,240,104,100,165,48,186,90,184,32,5,243,142,221,16,74,50,139,8,94,180,111,184,20,6,82,225,204,4,32,97,179,52,155,28,105,30,98,115,180,151,27,73,95,173,191,116,86,32,0,0,0,17,116,97,98,108,101,95,118,97,108,117,101,95,49,95,102,102,116,0,0,0,64,140,103,87,66,166,138,247,159,31,154,36,121,27,152,208,193,182,71,14,162,66,134,110,190,60,11,96,145,210,46,198,95,108,227,22,21,195,139,240,147,205,30,117,36,166,25,81,67,39,147,155,237,59,8,108,121,44,115,80,21,63,134,227,73,231,126,174,61,98,20,150,255,253,37,63,92,122,100,59,77,90,38,219,113,174,56,146,157,24,83,226,159,234,123,140,2,232,45,149,145,108,19,155,216,138,244,173,56,43,250,71,246,66,33,59,153,249,80,120,210,209,90,128,255,196,198,145,85,244,70,240,104,143,199,50,213,73,51,146,54,30,61,126,10,4,93,101,150,216,149,79,229,242,12,27,224,27,33,228,85,100,232,226,122,182,17,216,186,114,187,122,134,198,82,59,5,192,57,90,9,176,118,154,17,226,119,178,199,193,180,95,74,45,233,188,178,46,160,162,13,134,80,217,211,161,149,21,247,130,185,30,181,210,219,218,189,104,39,246,148,162,189,148,3,49,171,101,159,133,91,159,173,109,132,64,178,71,20,12,78,178,231,161,233,124,188,66,10,59,222,121,111,155,117,167,21,154,142,187,119,202,36,174,24,40,2,186,245,49,221,178,166,130,8,59,40,168,203,106,153,173,160,43,134,220,54,78,93,216,166,108,139,69,1,34,227,150,81,203,200,205,171,214,84,20,251,222,235,176,176,178,86,194,79,191,60,84,129,135,29,210,192,225,172,200,213,42,48,204,118,231,75,243,120,198,171,213,196,111,84,229,60,179,25,213,128,153,216,253,77,207,37,196,139,40,2,230,140,30,28,65,96,64,181,19,157,238,85,132,116,58,92,19,177,25,147,93,53,129,5,116,1,212,14,13,79,111,49,248,192,107,243,73,166,236,215,25,90,75,34,72,202,18,50,99,26,128,172,157,170,144,245,72,116,69,25,255,173,143,176,144,53,144,188,53,176,244,29,77,137,110,163,227,90,183,189,40,110,96,23,116,97,130,251,224,174,62,67,44,211,245,181,92,71,120,49,28,47,7,115,210,153,236,247,51,233,52,247,184,75,151,70,110,144,227,196,200,126,177,31,67,53,141,14,75,37,184,149,244,47,175,20,37,163,41,88,242,172,249,9,215,37,171,85,120,17,7,110,186,187,239,16,211,86,145,183,57,87,248,170,149,49,208,110,174,2,248,89,26,112,146,211,7,242,223,32,215,252,173,33,150,45,6,17,209,93,206,10,126,38,215,110,166,141,90,242,153,54,151,91,107,248,39,253,168,66,96,3,116,13,80,90,216,108,158,18,51,67,43,158,183,33,138,102,132,223,242,24,131,117,49,235,159,237,223,81,234,154,25,236,242,248,109,61,103,123,118,50,57,37,107,24,161,58,37,148,101,208,95,35,125,75,120,55,101,214,33,62,237,44,78,74,53,28,212,45,16,51,212,12,116,191,250,51,133,223,133,58,157,170,20,31,217,87,12,205,8,239,115,103,253,118,13,4,215,108,236,254,125,188,142,82,229,83,188,237,243,200,124,93,123,43,227,148,16,54,54,45,76,248,126,39,23,229,21,198,91,179,220,110,27,214,157,30,175,184,38,53,63,38,19,86,24,249,255,208,210,51,30,158,25,20,22,239,161,174,254,149,117,213,81,227,74,152,243,4,171,43,214,174,58,211,82,169,115,22,2,171,15,83,0,24,57,21,24,216,43,200,21,147,123,37,194,15,152,179,129,42,170,65,48,14,36,222,136,239,56,105,26,223,99,134,196,125,69,148,254,217,229,135,70,208,247,17,109,56,216,250,95,30,79,239,28,216,201,131,152,4,204,148,109,44,221,235,85,126,162,130,153,145,159,235,89,42,232,36,190,31,113,193,127,47,192,211,58,78,101,146,41,58,38,187,59,237,62,167,23,250,164,34,87,48,200,124,231,97,187,242,95,151,171,3,2,63,178,120,60,111,238,57,52,247,122,93,60,54,22,160,160,203,58,214,221,169,140,29,85,14,40,73,52,181,182,247,12,46,144,77,52,126,126,98,36,104,48,20,99,181,128,145,91,4,224,78,181,41,191,3,142,113,235,217,125,57,3,61,166,25,216,171,30,221,29,2,124,111,156,78,143,77,22,43,95,193,220,144,3,147,191,40,21,44,64,242,226,117,74,133,94,89,207,193,180,26,8,2,13,2,253,57,56,113,2,241,9,216,249,202,242,244,245,252,207,114,196,62,130,50,184,151,182,35,1,162,29,29,150,73,5,185,185,111,223,254,159,117,20,25,125,151,88,154,197,31,105,22,133,4,168,120,35,202,224,37,70,79,93,168,4,162,156,224,214,219,200,65,52,46,167,226,98,97,237,116,178,248,126,233,203,47,5,243,254,179,249,87,158,4,25,144,86,251,185,217,25,26,56,0,158,69,107,255,195,5,106,249,112,162,118,189,29,206,190,137,215,141,12,87,75,185,181,51,144,110,25,172,246,20,20,234,168,113,193,18,38,6,195,197,19,55,107,211,251,119,149,78,160,197,183,76,128,7,0,182,41,216,63,89,193,129,156,36,97,137,106,119,121,35,247,233,35,207,45,252,132,98,233,194,209,103,202,88,180,118,127,92,136,12,251,208,53,70,142,137,184,41,12,202,52,69,138,139,225,68,105,158,50,213,34,6,127,110,111,53,122,217,208,226,239,173,23,20,106,46,243,175,22,171,198,253,244,19,148,37,116,10,61,209,61,232,6,178,184,87,51,55,13,47,238,121,47,220,39,48,194,86,175,219,106,95,32,80,73,241,59,223,67,37,6,170,90,105,44,237,239,166,196,81,31,78,104,118,212,103,55,63,177,188,121,123,251,186,107,189,122,17,49,28,152,234,73,85,243,107,119,181,201,138,165,59,204,194,151,165,11,192,155,66,36,183,199,87,159,23,43,178,219,135,97,82,78,97,211,48,59,116,44,190,175,101,150,42,90,8,121,64,149,92,130,158,29,191,165,143,109,235,140,13,77,216,71,205,185,24,112,206,146,139,213,169,52,243,149,14,208,99,192,158,56,205,227,241,55,227,219,81,194,151,135,150,77,246,128,178,25,115,64,89,31,161,231,159,168,83,24,34,208,120,51,71,248,232,15,89,14,151,94,179,35,141,27,83,120,70,100,2,217,95,216,127,174,210,12,196,153,61,174,92,213,15,90,134,204,205,242,97,81,186,2,190,99,8,51,107,99,168,126,208,176,55,19,150,152,230,189,14,237,186,89,83,9,235,140,186,228,94,148,207,209,210,179,247,0,35,48,108,31,176,53,213,25,76,29,130,108,198,21,223,160,58,231,23,252,99,163,165,182,69,244,182,210,26,56,237,27,24,219,45,103,252,103,85,40,190,139,198,233,60,70,207,181,243,88,38,253,64,36,254,28,94,70,68,132,111,86,72,115,92,236,66,68,32,249,187,128,217,106,66,215,56,242,29,86,3,180,77,229,196,36,113,113,91,183,200,182,100,148,13,124,11,13,81,45,247,114,247,181,61,208,228,249,52,239,160,154,162,199,37,57,53,164,197,58,164,36,26,70,22,74,225,235,40,152,159,252,252,45,36,23,147,9,83,222,212,232,9,139,117,122,18,27,129,208,123,167,81,154,182,119,53,22,88,52,155,44,199,130,72,67,74,52,241,3,150,56,217,86,215,123,33,68,1,163,239,191,255,179,87,16,133,198,90,123,79,233,177,71,204,206,238,52,255,159,161,23,184,235,46,73,6,176,230,186,70,236,25,41,109,147,11,201,115,218,12,99,118,254,195,5,189,221,220,98,61,9,21,1,148,194,66,104,221,182,207,207,17,47,138,92,221,252,25,203,149,211,221,206,178,155,248,30,246,67,107,21,25,86,66,180,165,238,147,147,51,187,243,21,42,191,77,24,220,58,195,156,98,58,180,71,156,186,114,26,132,215,69,74,213,197,55,220,170,144,29,239,196,18,55,177,52,21,122,59,55,144,77,183,54,246,152,57,208,109,198,143,119,30,112,15,209,173,56,121,157,247,216,196,141,90,101,65,88,20,203,206,225,60,53,194,144,128,174,118,56,78,6,56,102,40,0,166,76,67,211,60,131,115,46,200,216,138,211,224,8,157,186,196,86,57,129,209,38,34,118,251,68,125,57,236,14,146,4,95,41,117,79,80,154,250,112,149,73,228,113,216,73,52,154,1,224,121,141,147,55,131,179,151,205,131,57,164,251,238,125,243,83,164,218,230,222,141,223,222,235,53,174,167,28,88,221,17,16,169,40,9,17,52,217,22,150,23,165,214,92,61,209,105,248,161,24,78,232,225,227,60,234,196,173,67,0,170,139,177,34,106,87,141,235,217,66,94,227,79,118,222,73,106,186,114,68,206,133,75,70,114,121,38,236,96,65,79,58,204,70,142,30,104,6,21,228,124,39,183,137,27,243,93,81,122,56,209,165,71,221,164,229,205,161,220,6,0,103,231,2,23,89,137,134,205,111,134,248,88,49,26,72,105,186,207,35,103,153,114,184,75,229,37,192,34,86,223,81,141,160,80,12,159,163,230,145,230,215,4,165,179,246,186,22,169,244,133,52,165,207,12,234,98,124,87,200,124,99,117,98,239,23,167,89,0,0,0,22,116,97,98,108,101,95,118,97,108,117,101,95,49,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,193,255,255,239,151,144,100,75,64,76,93,11,42,214,57,27,19,65,43,33,22,216,62,164,187,149,201,148,186,177,80,23,0,0,0,13,116,97,98,108,101,95,118,97,108,117,101,95,50,0,0,0,16,252,255,255,63,176,41,120,240,186,61,26,25,222,94,48,95,139,158,250,249,37,233,190,30,89,127,57,123,52,198,110,14,51,164,102,85,24,96,3,61,120,164,145,213,235,71,51,219,186,248,148,239,184,208,39,74,166,251,223,25,179,77,125,45,243,244,156,118,204,110,82,237,143,151,66,4,34,230,84,93,135,33,192,3,161,160,33,46,210,130,116,89,198,150,97,20,101,42,98,45,45,38,54,216,132,178,96,227,123,20,15,193,186,158,30,117,97,149,241,75,86,227,229,144,32,251,238,35,161,130,19,112,100,97,205,123,243,188,165,215,88,129,230,127,159,189,95,22,94,36,165,62,43,241,255,108,2,89,35,38,66,241,193,168,177,198,186,52,107,186,40,52,74,204,26,249,203,215,188,238,176,32,183,147,241,198,44,214,83,32,229,30,35,223,235,108,150,128,253,70,91,14,23,243,44,94,92,116,73,62,32,90,245,218,212,58,16,232,228,89,174,161,52,30,21,204,68,67,249,3,78,162,193,93,97,106,10,65,109,150,2,178,196,85,146,109,155,4,243,152,155,82,196,158,83,9,5,0,0,176,227,203,105,83,214,50,159,96,106,137,3,201,209,185,134,135,144,92,145,153,208,32,248,101,62,136,245,33,207,91,153,138,15,139,192,74,170,60,225,29,165,136,52,117,255,183,109,19,180,186,120,38,173,68,131,168,50,79,75,51,14,11,99,121,199,134,143,86,1,217,118,117,38,2,223,202,213,54,193,125,21,165,46,138,87,29,189,135,172,183,2,28,156,213,157,194,102,207,171,107,12,190,88,150,204,211,36,103,162,185,98,12,85,176,94,108,211,188,75,80,82,83,117,12,96,125,236,127,47,148,20,200,157,179,19,162,239,102,77,168,189,154,33,107,88,33,171,121,254,174,49,116,112,245,64,10,191,14,62,71,226,46,39,15,38,182,144,69,254,27,25,47,145,128,196,146,5,37,153,36,56,217,4,11,31,46,127,17,222,32,20,131,253,116,228,252,53,98,162,134,27,138,215,179,19,26,97,39,193,106,123,125,25,184,76,135,196,172,47,18,236,51,187,172,154,241,147,161,207,18,88,15,62,167,198,145,90,166,188,43,36,216,180,179,54,7,150,142,174,175,16,39,0,0,0,17,116,97,98,108,101,95,118,97,108,117,101,95,50,95,102,102,116,0,0,0,64,214,90,137,226,146,231,40,124,5,150,178,77,250,118,75,100,21,229,183,87,237,71,199,69,60,1,128,251,249,47,26,23,9,33,46,108,163,250,193,5,157,160,135,90,19,166,82,83,238,190,102,63,248,171,116,56,227,81,42,128,128,19,134,15,37,180,39,108,225,191,138,154,52,221,19,238,223,170,4,151,233,48,120,219,54,195,15,122,179,252,163,106,114,55,203,6,102,156,97,72,96,170,82,21,65,30,103,125,89,164,120,53,179,14,0,102,14,173,87,249,13,13,203,20,0,66,179,92,220,76,4,119,143,105,126,224,157,166,62,240,103,148,7,115,126,145,107,32,37,110,144,154,193,237,31,102,201,75,101,12,193,123,32,101,120,111,211,199,176,170,222,21,124,169,221,234,81,46,118,94,26,210,49,24,25,151,53,2,48,122,79,48,156,252,161,141,115,167,94,246,229,152,215,65,68,84,32,227,46,103,23,101,121,65,49,121,116,157,103,207,221,165,27,32,33,36,174,88,116,107,156,187,129,177,237,67,168,77,35,156,117,105,166,201,0,78,215,198,158,99,151,167,34,204,242,83,123,218,181,105,89,9,53,246,1,127,134,145,161,224,175,133,203,12,41,63,161,96,43,15,54,179,74,53,62,181,159,44,192,180,181,161,24,37,166,248,110,227,87,149,164,127,96,33,148,117,50,171,142,24,119,3,217,171,69,45,189,85,64,64,227,144,244,109,207,108,61,146,20,179,8,0,142,185,167,144,99,190,13,48,29,95,175,255,209,208,98,143,153,194,195,16,191,236,171,215,163,24,33,137,70,104,176,89,213,212,23,93,143,83,63,249,212,127,6,10,208,249,75,91,232,86,16,16,79,64,227,38,127,135,238,69,85,91,42,196,51,225,171,52,206,150,245,108,125,92,212,99,166,139,31,3,227,133,188,71,211,81,70,211,99,28,23,162,132,71,161,157,99,50,204,126,87,73,250,0,136,117,153,157,9,140,164,33,100,219,91,12,26,250,116,202,29,166,161,201,216,162,180,126,54,89,132,148,46,223,248,53,118,37,9,143,105,252,229,52,51,47,52,18,180,249,24,153,149,160,27,149,96,136,179,49,73,180,254,18,247,210,68,129,156,242,10,167,97,224,108,117,53,70,164,54,187,200,50,32,52,211,193,130,255,196,63,209,224,147,175,119,129,110,213,134,99,60,244,149,107,63,114,24,95,6,222,70,77,144,95,226,230,63,22,221,18,80,189,17,118,210,52,53,23,219,117,135,18,237,246,222,228,235,103,36,182,68,35,16,34,222,174,148,168,35,19,138,219,144,214,15,84,61,207,172,31,94,125,99,162,109,34,79,181,69,251,191,142,97,179,58,169,189,30,209,196,206,22,200,194,248,83,45,71,153,224,168,206,27,48,36,86,217,88,17,82,17,88,138,20,101,32,42,18,250,164,93,60,103,132,187,67,72,242,103,141,33,68,11,151,234,230,3,220,165,19,140,20,43,249,242,106,168,11,41,227,90,225,146,194,1,149,75,63,203,185,191,78,95,178,37,191,141,212,181,70,116,86,47,3,213,16,27,229,16,68,45,106,157,148,93,135,44,96,233,45,40,111,55,163,142,251,198,190,69,250,122,217,97,96,186,221,212,4,43,154,195,12,90,79,175,18,140,210,53,13,41,143,220,164,214,25,80,107,85,207,251,15,224,144,96,206,150,172,0,231,238,233,77,54,66,120,156,9,18,185,71,217,34,144,180,189,114,53,64,140,193,59,231,232,235,239,92,148,45,112,227,237,108,172,66,215,24,149,88,31,94,132,191,182,242,50,138,202,83,5,120,105,177,249,217,218,188,151,150,178,215,141,10,177,137,119,142,58,23,15,16,21,122,4,105,32,123,45,154,156,92,230,12,187,230,42,13,221,178,119,129,106,156,118,81,118,173,49,224,221,19,192,130,129,176,113,71,60,211,118,135,81,85,134,22,24,187,28,137,196,246,234,165,238,245,29,159,164,136,251,202,143,9,7,84,99,3,229,17,200,220,100,123,190,151,99,128,116,103,60,136,175,237,75,155,116,248,204,54,174,30,63,220,234,43,211,228,139,31,255,104,248,92,55,132,123,94,223,64,123,142,254,158,193,92,159,34,145,252,127,123,184,221,251,226,41,16,160,124,238,32,121,239,234,27,3,56,57,220,5,203,253,95,119,176,166,211,156,64,77,14,245,91,107,126,21,102,151,26,215,196,138,235,248,222,94,69,179,58,30,155,151,113,244,135,168,23,22,136,192,181,32,217,253,76,104,27,20,94,67,69,224,21,101,30,3,17,34,164,212,234,235,99,185,141,248,27,105,66,234,188,193,230,235,229,150,99,54,43,206,124,217,38,85,26,27,212,247,216,247,157,205,147,119,197,46,159,51,179,70,103,156,247,140,160,253,200,210,89,229,110,244,2,250,53,17,222,4,60,183,15,35,148,145,186,124,52,186,235,153,159,60,155,221,117,146,191,74,12,241,217,42,242,208,87,3,71,202,178,42,229,31,49,25,158,48,236,45,65,78,207,144,38,48,214,202,145,66,199,166,235,158,106,6,253,43,188,237,63,238,21,138,9,197,244,5,185,234,70,237,18,160,122,158,61,24,147,171,215,219,33,98,190,4,71,182,145,218,209,4,74,153,235,12,147,164,1,126,158,255,185,106,172,137,154,210,126,197,190,159,146,34,83,47,113,131,171,238,250,35,205,154,35,162,93,23,48,247,103,0,148,132,62,55,108,162,51,132,200,224,178,9,165,241,154,191,29,231,121,148,44,97,240,6,20,247,169,155,41,157,47,36,202,118,0,62,37,65,179,227,101,247,68,85,169,158,110,193,107,160,215,90,23,228,92,166,68,7,19,15,254,169,193,60,112,6,102,71,163,17,20,140,59,69,24,62,216,69,208,4,250,206,189,57,205,49,15,224,13,12,201,45,179,179,144,103,224,71,252,169,156,170,173,250,71,153,155,205,136,213,185,150,107,45,103,116,146,16,101,188,7,33,108,80,177,118,204,192,132,161,16,27,176,79,236,86,0,181,66,139,171,201,186,149,184,126,14,213,12,123,64,206,20,139,109,34,93,206,70,239,241,104,8,237,221,72,155,212,49,165,158,192,235,201,204,132,167,104,153,49,179,243,30,3,52,123,230,54,248,231,148,231,117,229,15,250,137,29,184,233,29,92,193,231,42,207,48,147,197,162,161,2,92,132,53,223,37,75,169,24,182,112,132,16,139,195,155,42,79,70,8,117,39,65,45,49,30,64,20,4,94,212,73,128,224,61,140,98,86,252,86,198,216,97,157,126,7,234,151,58,20,225,252,19,127,57,196,91,50,147,122,135,212,181,76,71,150,128,119,172,57,18,241,81,191,125,17,164,217,109,47,142,217,118,187,123,218,236,112,216,64,124,16,237,13,59,240,172,13,105,82,37,80,163,42,61,225,31,203,105,170,63,201,121,130,216,27,219,97,136,140,199,193,242,254,74,123,110,225,164,230,110,174,6,53,169,57,199,76,43,129,235,3,118,196,17,123,212,115,88,4,72,240,103,221,88,221,35,48,9,132,110,163,25,45,63,48,52,225,33,90,92,244,81,123,15,196,222,11,138,134,100,251,102,118,149,50,187,82,75,18,227,184,249,146,19,62,237,69,239,152,186,195,216,68,1,186,27,176,10,0,74,38,166,221,33,140,108,7,183,128,154,163,146,10,150,119,179,253,0,0,106,49,151,187,3,208,35,60,188,125,173,215,144,241,180,212,123,252,255,129,226,20,145,141,239,18,203,36,53,92,42,3,179,149,121,238,72,219,238,167,6,143,47,97,89,139,80,99,145,251,161,208,1,163,52,88,155,173,78,181,233,35,160,49,228,254,196,199,26,86,49,239,26,167,52,96,141,87,186,47,146,117,5,92,83,128,90,160,167,162,182,71,98,61,252,44,235,110,128,162,166,116,188,177,194,43,96,200,253,133,163,192,102,68,47,150,54,7,151,13,223,210,244,250,122,131,47,43,172,6,160,228,149,4,95,139,156,173,228,54,29,239,69,236,136,216,223,105,63,213,124,134,209,39,181,246,243,136,2,58,213,116,170,196,13,116,91,80,201,198,126,126,4,227,140,47,96,240,49,141,44,18,235,63,111,162,3,8,84,228,24,92,185,17,87,253,251,124,118,169,217,162,138,26,127,46,191,0,1,174,72,177,171,240,4,215,74,50,253,170,177,219,77,63,118,90,19,188,209,136,76,194,100,1,144,47,58,19,131,175,126,24,31,207,162,247,20,92,108,204,174,212,131,15,207,64,247,1,235,98,134,213,166,154,194,111,248,82,215,27,31,33,49,184,186,221,159,127,201,31,11,30,197,163,77,43,182,6,93,119,111,118,155,113,193,161,28,192,219,127,8,114,208,130,132,82,77,158,13,69,29,14,159,4,111,7,64,90,37,3,46,203,20,171,185,123,238,102,81,89,3,69,53,101,105,199,109,37,113,103,164,81,106,55,155,138,101,96,252,68,62,1,149,134,100,231,136,40,84,219,214,200,81,239,214,75,216,107,64,162,0,176,34,65,26,141,204,184,10,123,60,110,95,4,0,0,0,22,116,97,98,108,101,95,118,97,108,117,101,95,50,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,255,255,63,180,196,250,247,105,25,190,170,191,76,54,82,65,135,164,153,133,123,173,10,235,116,209,46,124,41,91,37,0,0,0,13,116,97,98,108,101,95,118,97,108,117,101,95,51,0,0,0,16,252,255,255,63,176,41,120,240,186,61,26,25,222,94,48,95,139,158,250,249,37,233,190,30,89,127,57,123,52,198,110,30,35,157,169,95,228,105,148,207,233,229,251,4,60,63,43,10,160,109,12,169,117,31,103,96,110,17,210,172,146,65,210,37,183,204,247,224,211,98,27,241,244,230,26,132,22,49,174,162,172,121,177,33,207,20,62,103,111,74,129,251,123,227,171,25,30,144,243,107,127,80,58,16,143,172,5,107,133,120,193,89,122,72,13,67,85,3,142,160,112,205,168,116,74,152,178,38,153,81,1,53,104,92,25,165,161,184,10,207,25,195,54,90,166,103,151,52,152,10,201,136,155,227,201,197,198,218,145,7,189,200,149,47,157,137,50,100,180,115,40,87,181,146,36,121,178,231,212,187,128,58,80,195,171,216,95,198,63,174,26,22,57,181,17,84,26,103,166,30,62,31,170,234,59,130,79,208,200,52,162,86,174,228,99,189,237,148,89,128,84,183,234,13,180,160,231,74,206,202,206,6,68,44,214,95,236,250,89,57,67,40,113,72,208,8,155,232,215,218,100,113,213,99,153,2,5,0,0,176,227,203,105,83,214,50,159,96,106,137,3,201,209,185,134,135,144,92,145,153,208,32,248,101,62,136,245,17,222,98,86,144,175,139,77,116,167,138,189,116,12,169,8,30,189,234,116,216,64,38,233,87,187,142,95,52,224,12,146,10,74,51,8,15,192,146,198,82,156,137,158,245,49,183,133,133,176,222,207,95,231,48,18,81,186,85,176,229,246,106,184,22,227,111,12,132,20,165,167,51,2,196,179,14,195,111,114,206,226,15,116,62,97,66,194,23,185,210,136,108,40,182,177,9,104,174,254,186,43,153,200,158,239,183,174,170,46,37,253,205,182,240,233,76,30,59,135,47,142,188,103,27,172,115,210,40,68,55,106,192,246,107,175,223,220,252,144,34,147,85,15,175,170,112,172,197,53,11,0,245,125,199,209,26,51,160,73,26,200,74,238,155,121,142,59,37,83,81,15,143,12,102,228,87,148,35,223,42,8,97,236,250,59,11,216,96,30,151,121,34,77,95,24,165,197,42,19,61,77,68,227,25,92,237,217,238,25,48,16,57,230,60,181,207,81,197,204,111,157,234,202,45,0,0,0,17,116,97,98,108,101,95,118,97,108,117,101,95,51,95,102,102,116,0,0,0,64,35,78,187,82,59,37,0,36,159,227,108,143,178,14,98,127,139,139,229,145,187,218,16,246,184,215,52,9,122,28,155,95,168,94,69,163,171,84,87,255,142,3,13,132,17,3,188,179,111,155,52,148,33,219,29,104,237,112,103,173,167,61,241,53,99,233,160,154,96,107,127,53,107,148,232,127,69,241,205,224,120,59,21,69,191,77,141,86,78,166,101,53,250,242,9,11,227,10,46,15,192,75,40,14,102,215,102,72,63,102,117,76,198,163,67,177,108,195,230,103,32,31,228,72,200,110,112,51,199,82,24,85,75,236,111,183,165,107,23,23,139,164,44,84,16,207,245,46,149,23,194,120,13,175,185,143,207,97,19,84,31,15,94,63,206,194,176,24,128,10,252,30,122,232,179,248,64,123,19,53,59,115,25,215,121,86,234,29,17,142,163,70,10,16,135,120,36,185,56,155,180,112,28,54,158,42,247,166,125,188,142,147,105,97,55,124,86,115,167,40,166,63,62,12,14,157,246,65,167,154,243,253,225,140,110,104,47,206,158,113,33,226,38,37,97,14,123,90,133,8,32,60,81,55,17,1,94,38,176,59,16,217,127,91,254,220,197,32,162,180,20,181,206,193,25,89,7,129,140,245,17,6,205,166,133,208,185,92,166,194,254,215,195,93,102,134,36,148,113,110,234,130,130,157,89,63,131,103,255,244,154,63,156,199,104,91,64,141,48,2,245,96,7,31,106,249,49,56,238,95,227,45,113,226,188,157,78,16,45,141,11,199,251,157,248,192,93,39,168,133,28,44,187,77,47,157,245,153,5,58,221,224,217,119,223,244,116,140,247,138,197,23,77,148,67,57,108,94,72,146,207,250,176,65,143,49,87,60,222,98,173,16,62,47,245,188,188,151,164,246,153,178,213,164,42,19,136,170,91,44,75,78,151,250,106,21,169,245,252,213,94,238,97,15,246,191,192,16,11,172,145,170,133,232,63,71,84,8,115,148,242,246,41,10,205,164,65,54,9,33,244,206,114,250,172,165,38,135,27,4,227,0,80,89,134,45,62,246,233,68,203,143,142,8,26,134,16,46,27,53,36,190,164,51,76,38,157,80,59,112,254,212,36,221,159,165,158,160,14,119,171,121,26,64,33,15,161,155,61,130,244,43,162,58,212,152,154,89,169,22,216,231,245,185,202,60,51,109,139,20,151,184,8,65,184,82,214,225,4,46,181,144,81,76,201,194,240,185,79,89,85,75,127,18,32,49,82,110,210,14,195,189,195,17,124,151,141,186,85,202,127,238,147,28,168,13,17,121,50,139,153,37,156,173,50,66,186,6,37,5,109,110,159,206,26,117,90,64,43,178,119,146,136,66,182,71,240,66,25,86,210,137,232,98,8,252,31,33,72,55,17,231,72,26,56,97,62,10,191,133,99,216,110,6,220,230,24,151,108,71,177,52,79,119,135,228,100,128,123,86,137,42,138,211,175,113,130,62,219,33,113,26,106,204,123,137,55,200,202,226,236,47,225,97,6,56,145,58,173,57,3,107,144,234,140,136,46,30,50,35,42,68,118,3,151,152,170,246,68,199,174,75,234,59,34,130,2,182,19,82,7,177,143,5,178,48,154,48,61,119,76,110,90,130,237,67,209,181,200,243,34,207,144,3,249,29,242,50,79,121,214,162,229,100,25,50,142,136,219,100,162,106,8,138,134,102,63,179,54,226,179,59,218,236,200,153,134,41,70,247,226,21,78,177,41,86,231,255,96,6,7,250,83,5,50,58,211,253,249,49,226,138,232,180,110,161,128,138,78,19,220,193,33,212,210,240,182,36,43,240,224,244,117,236,176,12,174,137,157,105,70,135,91,61,93,144,213,212,240,169,89,47,95,76,239,149,55,53,249,255,197,233,182,69,214,90,146,251,13,80,228,182,221,203,61,143,91,80,190,164,42,11,30,25,207,140,198,225,136,74,38,243,3,34,32,238,62,117,195,210,91,148,44,197,255,115,216,149,61,149,70,61,179,236,118,21,125,90,146,152,183,203,137,13,8,114,96,0,254,134,89,162,59,105,40,48,34,237,10,199,132,243,172,34,8,45,203,13,208,29,249,65,8,187,56,210,244,154,218,98,57,39,255,171,218,93,130,41,236,167,173,61,19,69,241,7,147,221,189,39,114,55,40,23,126,210,170,121,154,166,243,192,81,141,37,16,82,238,219,51,250,201,26,98,79,25,134,171,229,130,220,65,171,231,247,217,51,137,244,73,138,36,234,67,254,156,108,166,25,231,208,114,78,192,55,43,35,85,197,251,30,85,221,3,123,220,108,132,149,117,137,171,99,106,200,255,134,213,125,125,204,123,104,134,135,26,169,154,139,55,153,68,16,148,29,38,12,48,29,24,153,182,53,98,129,13,183,138,191,248,251,102,201,200,206,245,168,158,132,212,135,229,11,84,17,120,231,20,215,2,84,68,222,176,44,124,44,96,229,126,203,101,114,44,83,48,248,37,17,72,42,69,230,59,192,149,1,234,78,65,21,94,85,4,170,127,212,38,49,199,120,215,131,253,234,253,67,225,31,187,23,5,112,147,226,18,85,24,249,94,117,87,39,181,148,198,109,231,46,93,14,215,146,34,63,227,252,136,158,136,75,162,31,185,10,38,173,24,24,60,195,230,53,46,185,253,72,51,237,74,198,108,38,182,155,34,69,114,18,40,243,193,44,129,135,225,113,201,242,14,8,37,2,145,102,64,56,140,64,214,82,233,186,59,216,150,120,118,34,240,27,105,213,204,88,236,85,86,201,73,157,42,46,77,69,136,173,6,206,5,207,236,209,1,47,17,171,211,72,85,62,195,39,230,22,32,248,180,238,172,232,201,35,163,12,152,139,224,66,29,68,99,134,54,112,174,161,37,11,246,57,226,20,225,84,21,105,89,29,97,170,202,214,51,182,71,170,158,153,85,242,81,190,137,226,37,210,196,76,34,114,57,174,169,231,111,104,130,229,94,83,68,241,90,189,8,200,66,19,123,236,214,226,0,115,116,224,179,72,193,127,91,156,174,19,136,37,41,90,146,121,231,22,38,48,72,59,208,7,28,244,90,192,123,232,55,71,98,17,99,56,154,176,206,84,234,52,130,182,145,193,56,47,79,158,86,113,127,129,135,76,0,136,131,192,78,188,59,35,189,19,74,43,71,160,17,156,70,100,73,104,56,8,33,15,139,83,136,90,181,179,101,0,157,170,107,1,77,45,89,139,103,164,209,212,190,200,190,146,131,46,179,250,28,82,146,168,249,41,100,249,80,74,201,232,140,135,31,245,64,21,52,251,73,233,27,121,255,38,20,112,164,131,193,93,249,24,168,174,51,206,141,71,241,50,42,88,188,22,124,216,172,155,28,38,161,127,144,74,207,31,43,198,126,12,241,49,50,215,73,56,105,54,68,193,1,31,33,117,7,54,28,9,83,50,34,96,144,85,97,58,69,58,72,55,189,165,125,236,67,117,74,134,201,154,10,121,122,117,89,185,237,40,75,208,107,225,19,25,62,234,211,27,94,178,237,165,114,217,20,189,190,24,105,147,227,161,150,154,39,62,13,52,51,244,60,168,228,3,78,75,65,115,88,233,171,69,184,132,113,52,204,78,161,52,223,144,243,228,23,213,40,242,29,58,88,57,140,197,189,205,41,61,66,181,103,37,29,182,118,147,230,12,164,59,107,108,63,47,218,166,18,59,235,189,255,140,38,70,171,156,177,15,26,233,72,5,250,7,138,96,72,47,95,177,178,107,7,152,20,119,116,30,72,114,90,113,63,70,131,95,77,38,55,233,36,55,161,150,255,148,156,18,186,57,64,144,15,23,30,130,208,222,139,46,136,173,3,181,10,72,199,9,55,24,84,42,57,10,176,113,163,142,222,167,191,140,10,219,157,168,36,142,3,170,253,65,100,151,14,41,78,232,199,175,171,36,146,171,85,194,99,197,253,80,145,163,112,32,47,64,58,214,45,235,49,12,113,208,220,117,27,5,54,240,108,86,73,14,240,129,46,66,66,113,7,199,232,55,254,149,203,223,65,91,7,236,33,47,0,23,132,206,75,28,25,220,224,62,82,119,161,91,10,12,47,144,66,78,113,3,54,223,166,72,62,67,164,249,39,209,131,131,111,45,143,53,45,186,51,64,229,80,8,245,61,61,137,172,42,234,118,119,215,158,33,196,237,49,59,166,221,181,133,28,141,252,192,210,22,222,228,233,136,186,186,143,49,147,215,20,120,102,243,173,47,4,185,79,79,20,153,251,217,98,7,83,36,237,144,139,23,205,20,239,221,207,34,246,80,69,120,36,147,54,73,162,141,60,13,76,60,167,169,147,32,85,14,132,248,39,191,151,177,205,98,149,60,173,99,129,3,238,167,80,206,206,220,109,95,188,88,0,118,245,240,66,180,142,108,201,150,211,172,149,54,112,103,1,8,128,77,99,3,70,61,160,191,57,125,56,25,219,241,165,187,73,248,54,147,209,9,241,151,179,3,255,102,61,95,29,80,222,55,144,38,141,105,226,28,83,100,103,153,28,124,91,187,149,115,146,243,149,37,247,120,79,145,125,194,111,78,3,86,111,97,224,15,0,0,0,22,116,97,98,108,101,95,118,97,108,117,101,95,51,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,182,255,255,159,60,3,175,96,2,118,101,208,12,219,254,96,18,117,156,144,62,217,203,184,240,179,167,231,202,82,1,3,0,0,0,13,116,97,98,108,101,95,118,97,108,117,101,95,52,0,0,0,16,252,255,255,63,176,41,120,240,186,61,26,25,222,94,48,95,139,158,250,249,37,233,190,30,89,127,57,123,52,198,110,46,19,150,236,105,176,115,37,98,91,39,102,52,140,54,35,57,133,226,131,98,50,110,166,118,54,39,196,63,114,53,39,30,123,164,82,75,219,86,228,244,89,54,243,3,11,124,7,232,209,209,162,63,253,136,90,160,12,18,142,157,49,48,246,30,215,245,132,170,209,122,62,72,153,166,170,242,142,220,115,242,57,242,251,16,73,113,42,245,138,183,107,88,116,53,118,41,146,32,239,233,255,76,71,18,225,36,41,64,35,237,186,92,10,106,80,212,136,54,61,139,53,118,197,255,253,170,100,25,56,160,105,182,136,76,170,147,253,44,40,122,32,89,46,249,152,247,236,136,80,84,233,242,101,234,146,182,43,60,80,13,80,139,55,43,50,67,49,58,178,160,246,91,147,142,118,84,165,131,165,212,29,52,67,248,244,225,255,135,109,27,5,46,84,117,138,66,55,135,49,175,87,107,4,207,22,157,122,4,225,246,158,188,196,233,234,132,230,188,95,113,89,119,67,44,6,0,0,160,119,193,75,151,103,163,88,218,178,113,55,241,46,18,8,9,71,162,225,81,250,192,41,71,177,214,89,50,238,105,19,134,227,129,188,225,53,73,83,69,188,177,16,239,215,117,253,30,132,215,169,65,243,120,109,161,0,25,61,18,134,91,173,164,184,158,253,78,55,58,198,117,61,108,44,64,139,134,222,65,185,188,245,23,29,142,163,67,65,30,110,17,42,10,123,69,194,122,163,251,247,201,14,135,185,11,192,53,35,102,133,112,109,212,37,195,158,232,197,136,254,24,238,6,111,223,16,6,148,168,154,49,176,75,144,57,37,251,120,203,82,238,48,173,45,15,19,45,244,41,108,225,116,163,255,22,201,95,150,57,11,169,55,176,147,67,145,255,39,143,5,47,196,96,148,248,101,241,102,197,195,181,158,42,71,18,20,35,178,116,200,180,245,167,146,77,112,64,124,151,253,65,241,251,20,45,93,46,79,87,93,120,94,94,99,58,120,129,195,50,173,138,117,173,92,110,176,148,57,5,181,170,49,75,185,35,124,97,226,196,241,91,101,51,67,227,209,111,25,215,32,4,0,0,0,17,116,97,98,108,101,95,118,97,108,117,101,95,52,95,102,102,116,0,0,0,64,109,65,237,242,39,130,49,0,133,223,250,99,145,237,220,33,234,40,143,71,102,156,105,125,184,205,84,115,161,29,239,22,71,156,92,218,179,174,236,248,128,102,146,173,15,96,37,20,241,119,2,233,74,10,199,151,247,143,164,218,206,103,92,92,162,30,26,185,115,12,86,20,51,188,118,139,243,31,203,82,101,158,51,48,254,29,91,235,18,240,88,225,244,252,172,63,97,121,250,197,179,226,223,74,28,1,32,141,109,16,166,139,54,145,8,126,129,31,198,142,92,209,46,94,3,234,145,58,175,88,44,99,75,142,187,194,249,222,195,208,212,251,181,188,138,3,252,184,225,239,2,46,220,143,190,21,125,140,148,10,125,162,155,25,36,22,142,105,79,106,25,40,120,39,138,6,48,200,176,11,92,20,1,150,218,21,159,57,242,161,247,92,121,35,108,83,105,192,244,131,20,185,26,164,64,233,1,147,41,106,135,67,16,199,141,55,98,233,24,99,225,39,197,40,253,21,63,11,2,181,14,200,100,73,98,128,71,31,130,151,135,11,170,131,46,90,191,94,191,237,11,147,101,63,248,14,63,114,170,45,159,189,6,57,216,89,146,188,17,184,17,148,23,198,7,112,0,22,77,107,154,24,236,85,231,78,11,44,143,208,71,222,42,119,204,223,141,150,183,180,9,63,64,146,54,18,88,168,147,162,175,164,220,195,32,45,28,176,77,85,6,49,26,224,112,144,68,154,54,156,4,226,11,35,158,130,220,9,203,104,67,233,247,131,245,16,39,222,67,250,16,23,182,174,178,114,179,37,8,167,226,232,73,28,161,44,158,147,2,106,202,180,14,99,48,176,222,34,19,232,67,80,237,66,209,34,203,49,101,41,48,99,73,228,50,169,214,30,5,9,32,127,184,223,68,85,220,97,100,13,218,91,49,12,226,67,127,153,179,216,89,192,172,124,103,56,224,131,178,37,87,214,179,135,133,141,32,155,76,139,219,97,175,242,53,110,39,96,247,71,115,227,51,89,214,61,227,250,200,15,71,192,231,245,128,35,2,53,167,30,61,216,137,116,28,246,122,222,157,39,149,130,48,190,150,161,0,80,167,200,2,242,72,238,116,96,163,198,89,238,112,70,122,145,10,222,6,163,184,12,169,81,137,172,117,17,1,224,144,170,176,10,172,162,180,229,182,98,149,186,88,234,173,69,124,15,65,132,151,67,11,27,197,81,69,245,129,145,184,114,148,185,235,212,130,80,46,10,112,232,110,160,17,156,229,65,36,150,198,168,151,184,113,244,44,11,0,20,182,129,138,39,37,209,137,243,157,253,245,204,10,48,31,63,184,134,18,19,52,21,58,223,21,197,221,45,45,75,136,238,133,82,120,1,24,236,235,216,130,199,146,76,125,99,68,78,203,110,113,236,29,231,97,91,46,98,170,122,84,52,80,111,249,144,210,97,69,69,179,100,32,237,134,133,27,216,109,146,207,63,6,143,192,12,227,231,117,157,42,29,206,54,222,104,43,237,203,125,227,227,53,154,173,155,130,201,118,238,71,96,254,80,239,76,135,73,40,120,71,146,5,56,44,26,220,102,112,238,199,98,114,0,20,196,103,29,34,163,230,119,148,71,189,140,110,177,226,33,7,83,164,53,109,224,173,66,150,182,139,86,110,5,160,228,52,248,48,180,229,97,13,168,158,112,126,110,164,75,239,229,228,22,255,203,26,52,59,65,20,82,188,25,227,26,122,137,62,75,4,154,216,179,27,73,40,141,189,15,4,7,48,232,96,134,239,213,84,210,197,13,34,43,36,90,141,44,213,18,146,229,61,28,158,120,196,63,5,225,222,148,62,50,180,234,2,118,200,62,247,118,20,23,176,136,201,161,254,246,179,200,239,169,138,168,14,145,157,56,78,235,108,60,250,91,97,58,106,239,55,125,150,132,194,78,222,150,11,19,160,77,16,19,145,188,238,134,247,211,110,234,154,159,148,147,20,66,194,53,93,139,232,241,106,14,94,33,244,96,193,29,30,123,45,130,60,217,187,226,224,117,114,5,152,162,34,244,174,132,241,77,102,80,221,7,68,204,15,32,204,86,102,116,125,23,151,3,33,65,128,237,74,37,79,161,89,196,193,116,130,231,121,198,124,110,248,80,183,137,237,14,67,242,97,29,239,191,136,147,160,164,244,43,85,103,25,152,207,211,143,18,161,13,152,253,127,54,111,247,66,81,189,56,130,10,101,152,42,20,48,26,21,96,226,89,62,129,128,61,162,191,15,226,255,155,63,166,197,61,183,127,130,55,164,83,23,163,116,218,187,207,210,246,131,90,94,21,157,5,55,7,141,13,104,209,3,148,182,7,170,171,45,63,197,249,197,85,197,69,31,60,98,127,55,174,87,104,105,67,225,34,44,107,6,219,3,247,49,40,172,80,144,177,149,251,19,138,157,84,156,39,163,92,113,92,84,32,54,149,148,79,148,247,22,145,12,109,145,84,217,138,185,197,177,253,35,88,191,45,54,11,95,9,128,51,160,216,173,107,160,49,10,244,112,67,17,173,250,147,243,98,54,253,232,130,252,26,114,82,83,179,152,62,97,84,159,115,170,207,57,69,195,215,241,171,38,52,143,252,129,214,108,238,25,150,3,70,127,138,171,199,30,74,203,66,217,15,133,211,53,148,14,59,77,178,204,152,0,74,82,209,32,197,185,111,236,111,180,33,98,114,33,79,224,84,50,93,207,186,105,108,66,96,87,39,189,95,115,250,234,148,231,49,39,63,41,181,112,87,35,46,125,123,249,78,156,110,184,41,167,97,2,144,46,191,253,223,1,136,198,120,204,163,211,182,240,171,157,195,171,118,176,152,250,174,33,219,24,1,168,86,127,179,253,142,14,176,66,83,237,164,185,45,135,221,181,158,210,233,249,230,161,57,8,253,73,145,183,173,27,255,59,53,113,74,151,136,132,238,19,168,45,231,107,48,109,26,10,229,142,122,90,129,195,65,52,94,140,190,227,68,59,151,109,42,196,124,112,198,134,192,92,238,5,220,82,230,178,125,41,252,224,51,33,31,224,143,144,47,103,137,225,199,146,104,158,42,2,87,0,121,14,248,143,103,175,91,195,172,219,159,122,23,92,167,250,63,98,236,45,175,6,199,172,114,26,48,17,19,201,147,240,187,70,14,149,37,48,156,91,21,34,232,190,211,7,164,188,226,120,174,51,149,10,88,239,184,152,199,178,43,203,37,48,237,56,249,128,242,97,107,50,23,175,49,47,253,15,198,34,170,178,141,144,52,253,207,142,94,172,245,199,17,251,60,12,79,36,87,177,100,135,33,134,232,34,222,81,249,128,251,193,106,178,173,46,56,36,204,23,67,163,48,239,47,59,81,173,81,171,130,125,192,175,62,68,130,53,145,102,225,224,185,21,201,188,56,161,236,216,190,240,11,28,162,163,36,31,246,109,193,124,170,206,109,81,146,68,108,145,60,119,131,62,183,112,86,108,129,64,168,87,58,16,114,23,198,132,83,135,66,13,123,228,79,181,79,179,63,46,187,20,57,113,125,36,38,217,76,111,230,183,121,11,162,22,20,81,255,255,10,98,161,196,86,118,99,57,245,249,30,138,140,19,188,4,195,186,112,52,253,238,254,152,41,145,247,120,133,119,61,174,13,138,235,175,27,222,255,136,239,121,172,85,206,228,199,254,120,223,207,95,156,8,16,145,163,93,162,196,253,18,23,186,3,104,96,115,56,12,68,157,84,162,64,181,141,70,29,123,84,114,236,60,14,2,160,81,241,156,243,243,117,23,18,168,70,186,172,179,32,77,104,84,136,219,128,55,68,140,200,127,21,207,195,57,190,162,30,229,4,203,64,147,215,211,53,80,16,46,97,30,159,218,123,90,8,220,140,14,232,50,33,250,134,7,213,123,105,110,17,87,139,213,172,69,77,1,74,146,29,152,88,10,105,103,184,168,235,236,193,102,50,102,237,254,122,84,69,240,161,254,233,34,166,215,102,134,182,46,14,112,1,218,125,66,10,32,184,212,248,177,202,77,64,42,240,249,167,143,216,80,161,202,77,92,28,58,218,43,112,224,86,125,59,68,233,117,176,34,100,141,95,134,247,203,119,202,77,154,72,159,111,86,211,228,81,208,210,46,101,174,163,192,122,53,80,194,0,2,72,108,102,90,73,245,16,183,58,45,48,193,226,199,181,113,234,3,215,240,14,155,55,8,72,54,232,53,84,174,84,22,84,211,114,75,21,129,143,156,123,93,78,12,180,140,69,132,118,202,158,97,98,218,28,204,36,54,153,84,0,148,238,93,179,122,178,127,196,71,27,89,159,191,31,60,72,214,188,206,148,102,68,182,251,185,71,151,182,127,234,176,48,128,216,49,22,150,61,252,96,237,97,222,229,42,88,233,13,246,222,198,16,80,90,94,23,107,106,197,233,50,143,5,52,93,175,43,228,37,137,160,135,211,25,143,184,21,163,208,54,216,149,239,70,12,112,67,222,181,147,163,94,77,220,125,27,134,76,96,66,177,149,92,155,243,159,30,1,157,131,128,163,72,1,111,195,50,39,49,176,60,132,45,18,21,163,197,75,0,0,0,22,116,97,98,108,101,95,118,97,108,117,101,95,52,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,177,255,255,239,88,55,69,13,44,67,198,111,162,81,251,151,64,187,21,9,174,124,58,31,32,147,175,129,140,202,11,17,0,0,0,10,116,97,98,108,101,95,116,121,112,101,0,0,0,16,253,255,255,47,68,31,90,52,76,174,211,146,38,71,100,135,232,246,123,123,220,46,15,215,130,31,107,92,167,20,211,30,82,178,224,80,236,86,255,211,3,177,3,253,2,113,15,85,147,182,36,251,136,237,88,101,236,47,202,18,129,23,111,12,107,69,231,161,189,134,192,229,197,248,145,4,57,80,162,210,60,113,221,199,68,184,232,187,151,243,90,21,91,253,204,9,243,94,63,176,136,209,45,104,112,190,22,212,104,76,170,143,59,75,65,217,121,185,184,162,33,15,96,201,204,192,103,30,175,228,55,6,53,128,113,161,116,228,104,245,69,45,222,122,215,184,237,214,124,204,188,57,247,203,8,249,147,184,125,2,76,66,26,155,218,64,203,213,216,71,41,238,115,63,7,249,254,183,140,84,17,237,132,52,125,163,198,245,123,4,122,48,246,50,160,174,250,189,201,83,4,124,55,138,198,45,66,148,237,248,154,223,204,129,102,125,43,238,201,43,239,39,100,14,215,34,255,51,79,118,76,217,188,192,119,127,70,205,147,80,129,197,107,112,22,55,156,60,41,21,9,21,162,20,200,22,4,0,0,192,79,214,135,15,69,194,229,230,33,161,207,160,116,97,5,6,218,22,65,225,166,128,198,132,203,57,145,17,175,77,31,159,167,158,226,111,141,191,181,124,69,119,36,211,201,161,92,134,45,88,247,82,61,112,103,206,241,54,245,35,150,186,24,78,214,110,33,94,203,119,39,117,15,152,145,85,32,231,163,185,113,141,103,252,145,172,214,203,23,81,151,38,14,161,192,63,11,36,180,219,32,178,162,165,223,155,137,152,33,13,64,168,60,140,151,21,8,145,209,23,166,141,252,17,82,27,200,233,94,117,112,162,28,140,80,132,2,187,85,173,133,159,147,170,57,121,147,126,50,212,40,232,222,149,230,45,182,189,229,68,77,170,248,177,73,153,73,5,29,145,96,87,187,248,117,174,91,158,27,60,214,156,156,204,105,152,78,48,11,205,95,65,153,55,24,240,140,244,129,239,129,186,241,147,111,95,230,161,233,195,233,58,254,177,103,181,131,38,0,34,42,221,0,188,68,127,149,106,212,175,65,250,1,27,160,215,219,146,21,17,160,14,180,123,0,139,40,204,208,57,156,25,0,0,0,14,116,97,98,108,101,95,116,121,112,101,95,102,102,116,0,0,0,68,63,116,37,210,253,76,32,248,133,76,106,55,99,0,186,166,64,161,224,103,116,243,36,14,192,52,171,131,82,66,69,23,205,165,255,221,186,49,91,154,219,187,239,250,167,188,231,226,165,182,205,152,18,217,194,73,34,84,19,232,23,92,120,35,171,73,53,239,10,84,101,236,233,79,221,189,165,238,217,83,133,204,64,11,147,57,181,49,209,233,131,151,72,93,22,95,105,191,200,234,228,134,1,88,67,90,59,122,180,103,227,142,117,219,244,74,46,175,72,243,107,8,4,9,23,253,11,30,9,65,220,138,211,68,65,254,65,110,185,15,251,44,89,41,114,31,219,135,104,236,29,7,167,75,129,182,21,11,54,14,5,85,165,176,204,200,24,38,18,235,163,3,128,43,49,207,115,148,59,177,216,143,98,154,87,24,204,202,109,82,167,3,192,213,215,183,17,132,170,172,72,233,77,89,144,167,114,91,145,188,40,8,153,1,37,115,176,241,231,28,77,114,214,71,67,50,29,198,190,54,102,39,124,56,6,20,120,171,92,80,169,22,160,12,102,182,78,190,42,153,191,249,249,187,36,56,184,66,193,149,167,74,69,247,188,20,52,224,121,241,129,159,220,171,203,143,248,240,89,107,251,237,218,245,7,106,152,93,242,152,35,85,154,200,97,85,225,160,177,239,135,168,180,216,78,49,142,47,64,212,142,26,255,51,156,14,209,73,151,91,192,240,206,251,45,73,54,138,242,201,12,30,16,80,177,158,234,114,80,247,246,212,102,123,174,144,158,64,239,138,118,10,202,42,165,28,188,246,253,242,204,200,137,138,154,77,249,118,214,237,182,64,8,40,125,212,20,17,232,144,114,250,251,61,204,93,251,43,5,240,202,228,207,97,104,101,72,187,30,56,31,86,177,120,255,29,124,173,190,105,51,201,33,177,50,27,42,10,217,157,41,89,39,147,85,168,142,36,238,247,220,159,18,20,243,248,18,33,215,216,180,150,46,244,234,51,189,73,62,172,118,161,155,232,78,153,95,187,89,103,110,218,84,91,57,243,112,184,251,113,37,254,114,36,225,84,94,206,46,45,212,112,1,100,40,149,24,30,171,184,29,235,145,98,188,237,167,55,177,149,126,228,235,116,226,130,4,41,37,206,3,76,237,228,239,46,103,198,242,90,78,127,211,255,12,66,168,140,109,34,82,35,25,51,108,28,150,250,76,237,178,241,246,59,86,43,61,35,169,2,122,68,203,59,177,76,6,131,45,170,28,110,91,244,245,221,25,224,44,207,105,113,109,227,125,69,68,168,167,167,198,31,1,67,45,46,15,34,178,173,147,41,32,125,66,64,50,200,16,137,48,172,224,186,63,149,57,42,203,140,183,63,165,145,247,231,42,137,222,12,68,206,119,22,182,65,22,91,241,11,228,243,107,103,179,147,241,157,80,80,213,132,80,26,58,98,165,117,101,156,125,92,220,165,160,102,29,155,127,73,104,2,183,195,111,14,174,41,30,130,173,75,232,76,151,56,185,133,70,179,72,252,197,227,26,245,237,92,54,187,170,26,158,155,37,21,222,49,218,163,196,233,91,64,246,211,184,236,30,11,138,74,37,171,3,94,147,169,168,197,46,147,52,102,215,134,61,226,96,22,2,94,225,9,163,16,8,168,153,193,54,102,122,109,233,192,24,249,77,62,201,2,0,135,161,81,125,117,173,71,116,234,206,17,185,103,49,67,220,230,86,10,143,116,56,188,225,29,119,75,146,204,252,57,79,65,20,200,219,178,248,114,127,64,236,3,4,179,232,35,8,134,26,98,123,82,152,210,211,46,87,139,108,119,14,35,238,210,214,228,240,250,176,196,24,159,153,212,247,165,96,23,112,151,96,50,50,198,80,181,141,107,33,4,79,89,64,229,193,223,79,44,98,50,20,111,214,243,23,160,178,216,193,57,164,110,247,45,107,44,44,27,127,51,39,23,166,41,41,220,88,35,247,92,46,149,187,38,50,243,195,225,113,36,138,82,26,71,5,233,171,168,98,55,141,29,193,76,230,138,118,201,224,109,60,231,232,177,247,162,51,29,127,53,58,236,197,55,219,114,177,186,20,176,59,250,222,55,48,73,188,68,219,163,0,210,66,198,114,163,248,234,172,40,170,75,179,138,202,65,255,6,123,4,43,10,17,44,136,172,240,127,71,255,73,120,217,61,192,151,5,255,162,143,189,193,202,199,205,23,58,93,44,127,176,62,199,169,141,112,81,21,90,220,240,97,104,210,174,111,28,46,129,207,1,12,54,92,25,183,165,132,226,54,171,136,85,66,114,61,53,217,71,92,236,165,102,230,33,129,255,39,111,171,236,196,193,52,215,91,162,217,188,156,181,88,229,238,22,108,141,50,184,141,67,191,133,71,124,27,59,251,134,243,52,248,231,24,79,65,21,2,53,226,212,123,86,23,133,148,102,43,105,205,15,196,91,111,171,159,151,247,232,133,15,113,168,21,149,174,139,154,6,22,0,171,111,51,108,82,53,92,213,150,159,137,132,208,192,166,81,142,43,91,16,160,101,24,162,192,78,145,100,84,65,186,154,167,4,197,66,65,123,215,116,159,223,25,210,44,18,182,232,121,25,193,173,126,174,79,234,192,157,173,192,54,138,3,193,91,150,89,62,81,91,199,148,50,59,90,177,137,212,162,123,179,163,187,186,124,36,105,136,184,197,193,74,49,248,36,31,105,77,226,203,74,118,0,197,227,63,101,139,68,221,141,180,87,162,186,84,135,247,126,107,22,41,36,172,197,122,24,97,235,152,192,185,46,71,242,52,195,11,160,74,180,235,120,181,209,181,194,243,20,254,221,12,143,145,102,210,62,70,0,148,83,175,184,164,50,144,114,32,93,217,200,24,209,176,151,142,146,228,50,150,0,21,159,3,75,160,172,81,175,125,138,237,205,186,109,232,22,168,71,196,205,118,40,157,92,243,129,161,130,48,41,31,211,0,21,194,17,158,119,73,49,248,175,54,193,88,129,111,21,128,91,48,124,142,195,232,162,95,38,86,109,125,43,236,84,67,2,248,58,32,113,59,178,233,211,43,20,73,181,198,95,20,132,68,65,142,149,78,124,34,181,22,15,182,150,46,76,238,149,134,151,49,173,219,159,202,107,182,243,204,13,245,84,46,57,125,36,29,17,28,10,44,244,81,120,97,112,72,144,13,55,148,244,219,248,66,174,100,139,71,224,226,241,111,80,200,44,1,175,236,46,250,87,113,122,246,25,4,38,31,217,90,139,187,13,170,201,134,94,46,227,220,190,118,55,208,9,252,112,128,114,11,238,105,102,187,157,53,198,86,51,162,220,148,52,116,120,189,1,144,184,29,45,69,8,235,111,5,19,232,144,246,60,188,170,232,174,154,175,30,183,111,253,92,171,155,207,25,55,133,162,232,118,115,129,55,46,67,180,66,75,39,95,12,1,195,235,4,231,45,0,175,152,31,251,62,64,210,97,30,45,121,124,85,78,133,136,57,91,198,150,136,22,202,48,129,46,222,188,63,116,167,216,59,193,75,198,11,99,14,98,117,236,139,142,63,46,221,197,148,81,111,12,26,37,4,33,127,125,26,154,166,121,2,136,192,151,111,128,92,227,88,203,243,100,26,27,93,138,225,57,23,222,201,161,99,29,85,70,197,91,103,127,91,200,78,36,121,171,247,108,129,106,193,160,250,243,27,55,244,91,241,18,153,210,198,50,172,44,111,2,187,14,183,60,80,239,137,12,210,142,180,126,138,205,156,21,71,122,230,90,193,82,191,18,55,119,171,145,217,80,172,126,63,188,68,78,137,199,49,157,39,126,38,78,33,177,83,51,10,227,96,39,132,171,107,26,10,147,255,17,240,82,154,156,107,240,90,48,8,214,89,193,90,216,231,141,122,216,28,22,143,78,56,239,93,181,121,152,39,66,195,48,102,60,62,133,246,219,229,48,208,119,152,149,89,94,149,30,72,6,121,67,110,138,110,36,11,117,230,62,99,63,199,248,238,84,126,143,253,190,11,81,233,29,135,144,123,45,16,238,145,48,130,216,110,50,180,92,157,240,104,117,62,125,7,187,135,56,100,0,223,248,208,152,101,185,233,180,190,145,173,167,23,198,102,192,10,68,7,71,101,60,92,159,245,169,1,177,51,7,176,34,172,178,139,147,146,9,190,52,94,250,208,44,189,30,58,166,31,120,83,10,25,159,250,44,242,13,45,207,101,42,60,96,16,68,168,179,137,231,37,146,16,240,133,7,146,90,182,58,183,36,14,197,39,229,170,59,46,194,235,232,128,32,92,21,120,242,185,227,145,248,95,165,10,250,127,232,105,74,70,100,169,41,70,70,125,180,175,52,86,83,1,9,132,61,59,22,173,198,52,155,104,38,221,142,146,147,46,116,235,31,112,30,85,173,129,117,44,189,252,62,74,6,192,115,169,2,1,231,253,81,117,89,0,206,241,121,234,196,229,247,105,168,189,101,245,138,169,190,49,1,212,193,138,36,145,74,199,71,166,192,104,108,136,166,15,163,220,210,247,208,161,228,151,132,242,243,148,159,127,230,163,218,175,45,75,166,73,214,193,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,116,97,98,108,101,95,116,121,112,101,95,108,97,103,114,97,110,103,101,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,0,0,0,4,105,100,95,49,0,0,0,16,9,7,189,101,40,63,65,146,149,170,131,124,180,174,156,183,142,32,255,187,69,201,142,223,19,137,178,68,252,230,236,4,34,221,0,60,165,210,133,75,74,43,118,44,190,216,0,150,242,207,10,5,236,224,49,185,178,137,155,194,57,198,121,38,167,161,2,121,178,29,243,136,91,113,202,119,138,187,66,190,152,204,14,16,4,142,248,245,101,19,156,48,60,0,25,42,201,147,11,92,21,176,251,189,120,88,176,143,82,252,183,58,35,230,115,38,241,214,185,149,54,105,124,79,183,194,215,46,201,242,155,176,250,97,96,194,32,131,106,192,75,224,143,140,247,77,166,113,47,124,235,204,69,101,149,83,255,233,138,3,4,112,174,36,231,51,60,125,172,204,148,169,15,13,114,34,110,6,117,195,9,231,26,239,36,67,56,174,132,114,162,50,75,32,170,204,216,194,157,134,144,175,230,21,247,90,116,77,107,47,141,129,139,228,194,111,5,22,211,42,118,180,201,7,111,37,122,73,95,188,35,100,173,76,168,21,24,33,174,119,122,152,72,158,129,181,210,170,51,183,173,235,219,73,174,7,241,248,66,250,95,255,114,214,2,178,35,169,152,223,43,87,66,205,248,58,115,148,143,206,241,181,35,116,82,66,185,24,211,34,255,115,255,159,196,201,119,254,145,152,36,44,196,175,12,100,102,106,60,32,91,91,130,148,66,144,214,218,54,5,84,94,253,214,105,22,163,35,206,91,150,39,11,187,185,120,149,121,106,104,107,21,118,112,201,203,107,105,133,119,241,35,50,108,244,243,6,132,154,238,176,116,176,15,67,122,68,252,10,96,5,82,126,204,180,208,248,117,139,74,10,181,50,31,49,13,100,175,141,220,83,166,119,217,60,101,1,174,56,130,217,159,81,133,137,225,50,225,191,217,64,101,79,63,27,26,247,143,81,43,53,0,90,47,125,0,204,245,133,105,138,20,192,63,4,181,101,188,83,119,10,156,207,235,60,5,104,27,175,223,85,147,175,123,22,226,7,173,192,15,86,51,84,193,101,190,106,117,45,121,91,62,0,41,3,142,216,116,220,21,139,218,133,22,41,130,144,4,235,15,255,15,53,109,26,151,86,85,175,88,55,168,75,3,210,135,40,205,114,223,247,21,0,0,0,8,105,100,95,49,95,102,102,116,0,0,0,64,20,136,95,195,77,154,152,231,244,131,240,98,164,73,17,96,59,209,58,249,111,110,102,154,71,185,225,105,133,48,85,7,36,241,127,156,76,178,93,20,48,28,238,65,29,97,23,238,104,145,228,179,253,177,146,221,145,58,157,114,150,7,181,76,35,78,75,173,93,121,87,113,133,128,162,50,52,0,111,213,153,49,230,183,168,225,21,101,44,75,243,162,225,25,242,39,166,47,227,55,222,237,129,17,4,177,109,247,170,172,63,199,159,76,128,214,151,10,242,218,196,87,99,50,132,18,128,74,118,0,75,181,244,117,243,74,143,162,129,199,65,249,117,100,122,96,56,198,95,234,204,226,21,214,144,76,78,188,7,73,86,109,200,191,18,116,126,165,195,131,16,225,165,132,39,201,20,42,227,186,143,57,153,24,117,17,11,224,5,175,75,77,100,89,108,119,82,87,6,171,131,208,113,210,197,135,84,160,190,13,232,176,240,239,235,176,88,170,215,25,153,177,39,70,166,215,54,166,200,138,82,86,42,37,82,204,174,120,121,89,214,93,244,253,225,213,47,133,230,195,58,219,80,222,11,17,226,38,25,235,150,98,20,3,194,160,142,67,30,155,223,234,75,233,28,222,51,244,31,249,159,227,116,111,177,36,5,48,117,227,125,188,245,40,234,48,46,171,83,97,76,216,151,12,230,67,255,36,80,99,245,65,180,183,201,179,218,145,63,31,92,219,45,62,33,247,248,4,103,188,109,163,62,128,6,144,114,180,101,45,88,27,19,205,45,41,227,128,88,144,203,73,97,228,166,109,41,222,9,23,34,236,148,21,229,165,172,114,19,127,137,148,225,54,113,155,178,135,19,103,25,232,233,44,41,149,136,198,110,64,47,81,78,17,31,96,24,237,229,77,205,173,227,73,72,95,202,139,22,156,211,11,228,62,1,7,166,174,237,232,117,238,234,14,241,143,248,2,156,224,7,138,229,189,57,217,179,35,204,121,248,115,3,155,247,215,94,2,128,129,78,120,59,0,3,57,224,135,76,109,84,53,137,221,46,182,145,236,111,114,200,198,253,194,18,163,203,142,249,53,30,235,15,132,226,233,51,83,168,250,73,74,13,142,118,39,121,106,162,211,148,74,139,65,59,230,101,90,177,180,197,20,57,245,27,47,43,180,114,226,23,105,12,150,200,212,9,196,167,135,213,40,242,133,111,171,138,221,73,143,97,8,243,15,27,218,236,114,20,246,210,170,7,130,234,129,97,160,145,134,113,202,43,88,124,155,214,4,48,168,172,37,182,185,252,67,18,241,101,34,238,56,34,203,96,188,121,83,178,241,69,210,169,15,31,116,249,79,60,115,147,128,43,224,127,67,91,56,11,215,6,13,173,23,9,170,25,253,90,14,223,38,140,251,18,110,217,99,145,114,6,71,15,229,202,14,26,128,55,83,172,6,96,138,0,182,139,73,81,43,61,251,86,15,32,94,169,94,20,157,16,101,251,66,165,233,218,231,54,247,211,94,158,122,25,234,41,158,192,254,161,0,205,212,88,230,210,115,228,197,75,250,227,120,232,224,251,226,152,195,185,86,179,36,63,166,13,130,28,142,218,111,95,99,181,237,40,219,118,148,253,175,160,206,78,9,150,226,106,65,113,168,47,47,33,95,243,29,221,65,103,159,209,170,32,73,61,68,140,150,125,73,181,5,156,151,251,17,15,103,27,66,57,145,15,232,1,23,43,21,48,88,94,255,108,30,231,12,154,11,99,53,82,105,143,102,85,67,177,194,163,254,61,34,63,105,137,216,208,75,211,240,142,243,200,51,79,192,32,179,156,115,0,87,202,94,40,176,160,11,29,80,97,13,46,71,68,236,251,200,20,16,83,98,14,103,32,92,228,213,210,210,136,81,102,71,253,229,122,48,255,217,134,52,182,223,115,106,253,212,70,69,154,30,239,183,97,224,42,64,41,173,183,105,101,8,33,243,35,95,97,11,79,236,29,219,131,59,13,166,214,251,165,242,233,88,88,162,210,239,243,2,56,99,191,65,135,76,227,192,74,71,126,188,24,205,255,146,214,222,194,151,245,212,116,253,1,17,255,241,27,151,12,165,156,38,104,198,115,234,115,60,34,50,23,232,4,240,139,207,85,69,31,67,150,118,162,83,232,11,75,123,116,125,4,124,237,67,59,125,139,197,230,165,24,55,5,199,131,230,188,247,177,145,142,174,120,138,135,158,202,14,3,130,164,143,55,146,31,71,234,94,211,130,145,219,0,251,160,245,192,23,121,156,70,64,221,236,161,48,228,200,166,92,56,113,165,161,43,80,182,174,242,160,226,244,12,221,103,120,171,211,187,91,176,238,230,176,66,51,96,255,243,55,119,85,28,69,44,119,239,241,2,61,70,2,59,112,252,123,221,191,245,246,115,46,15,219,181,162,190,31,162,104,247,53,202,67,105,178,77,244,235,69,15,210,102,133,157,172,107,87,68,251,181,124,227,214,44,40,46,92,0,237,183,172,239,42,246,74,148,88,43,187,166,137,194,17,62,240,92,191,66,8,214,224,85,101,221,0,3,61,176,117,107,245,91,163,125,102,188,94,96,41,196,189,84,0,230,219,158,199,46,73,110,186,6,234,78,231,34,209,27,157,74,149,100,157,28,138,86,179,95,83,254,208,104,123,164,227,215,90,150,33,62,219,241,252,208,166,44,233,148,210,216,41,156,69,17,11,143,66,13,91,24,10,222,19,255,86,176,108,202,104,57,99,34,11,117,36,59,238,239,219,163,230,32,169,9,150,235,87,161,158,148,72,119,86,54,29,147,77,69,183,28,146,70,208,22,223,136,68,205,35,196,239,166,165,214,57,60,51,79,197,83,57,252,138,197,23,170,115,37,144,70,33,162,244,138,237,247,3,149,93,108,166,225,37,221,89,82,108,8,124,196,27,180,224,178,138,46,62,167,67,64,21,43,250,198,176,251,192,203,236,67,160,198,148,153,92,59,96,28,108,5,172,103,151,199,73,114,104,33,24,176,6,172,201,253,251,255,252,115,96,171,175,54,212,89,90,224,184,227,212,195,31,40,102,91,130,168,152,23,107,99,49,97,92,174,238,1,107,152,171,3,143,251,193,133,205,26,122,82,209,84,201,13,174,142,96,98,56,202,220,57,249,227,89,243,16,2,131,66,254,131,12,40,151,196,242,99,95,215,230,13,27,190,164,181,250,199,232,73,118,173,28,170,171,27,49,190,52,31,145,38,165,80,239,73,120,155,213,165,22,76,90,242,106,156,19,27,159,197,198,252,129,27,46,236,156,64,59,190,0,127,200,10,71,207,124,142,212,34,123,71,55,120,225,56,186,37,87,41,209,198,65,78,239,43,63,156,10,164,23,100,167,17,113,170,78,201,195,214,100,240,196,73,110,51,172,179,136,99,186,252,190,49,7,59,249,101,52,202,99,41,15,187,44,102,175,15,60,157,3,19,235,104,243,251,142,72,190,90,40,10,79,209,85,54,174,64,56,45,9,4,170,145,25,35,185,40,65,153,219,44,252,243,135,29,42,161,131,33,41,254,114,145,218,63,138,189,202,206,156,139,175,228,128,150,30,44,149,86,3,41,251,146,75,131,8,148,207,50,132,192,82,77,124,162,237,186,15,231,77,234,117,33,22,224,140,139,28,37,163,140,101,209,16,125,159,170,132,11,111,255,128,209,109,30,244,203,142,4,205,93,17,70,30,61,41,253,54,170,36,220,6,56,55,93,29,26,88,214,39,231,248,82,77,194,176,239,211,53,251,210,140,214,230,45,144,171,243,253,177,1,57,154,122,84,12,241,97,118,110,74,193,47,112,52,51,83,170,128,244,94,115,196,60,77,89,145,217,37,40,183,104,91,21,65,196,149,167,236,176,28,230,2,206,73,41,248,152,134,91,39,201,144,222,191,149,35,234,65,72,249,184,89,24,242,8,237,224,141,148,117,191,144,8,160,110,65,205,189,116,130,17,65,192,70,133,9,68,59,3,218,232,246,46,88,201,228,30,59,151,93,69,36,233,187,18,246,20,129,187,45,81,108,237,183,53,198,128,91,105,33,156,66,237,60,6,32,135,118,57,195,190,149,157,7,125,235,67,231,129,6,27,136,165,213,178,122,43,70,25,184,70,207,181,71,147,115,55,127,128,72,60,199,200,163,214,63,63,104,21,43,109,152,243,62,203,183,243,83,34,62,158,199,242,145,30,147,96,251,239,195,211,113,77,161,108,148,252,199,154,119,146,17,212,53,155,120,74,220,142,34,51,155,148,91,20,76,47,16,156,118,236,111,128,183,30,156,142,120,145,100,121,138,51,165,225,167,207,91,72,204,224,163,142,187,35,240,195,189,211,45,235,57,237,40,44,235,93,125,199,99,46,31,155,249,225,154,240,164,125,157,137,254,166,194,12,205,58,115,20,85,125,41,56,173,185,43,207,182,65,101,7,158,152,142,3,74,183,250,75,187,38,81,8,147,206,20,250,252,253,88,176,21,28,211,1,43,179,159,179,238,68,163,0,232,109,244,27,55,249,220,106,127,101,148,193,220,105,78,239,246,200,97,136,96,194,162,192,35,144,91,214,55,86,0,0,0,13,105,100,95,49,95,108,97,103,114,97,110,103,101,0,0,0,16,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,63,124,173,181,226,74,173,248,190,133,203,131,255,198,96,45,247,41,148,93,43,253,118,217,169,217,154,63,231,124,64,36,144,91,22,233,35,165,66,128,163,160,79,122,152,64,38,139,249,155,234,222,60,223,198,73,165,161,46,60,158,210,57,44,139,239,220,158,151,61,117,127,32,145,71,177,44,23,63,95,110,108,9,116,121,98,177,141,207,8,193,57,53,123,55,43,179,119,61,61,116,15,34,195,70,230,39,157,139,31,56,121,127,7,5,86,32,110,130,34,32,252,197,166,23,202,133,4,102,97,93,18,182,41,218,17,149,177,137,83,162,178,105,176,36,122,39,209,214,61,210,122,210,142,116,174,19,49,187,29,243,73,45,74,12,78,178,19,218,57,121,196,248,86,103,167,33,109,75,175,2,133,234,104,203,254,40,144,106,60,137,37,7,0,0,144,11,183,45,219,248,19,18,84,251,89,107,25,140,106,137,138,253,231,49,10,36,97,91,40,36,37,190,82,255,112,208,107,171,109,13,147,85,120,162,143,180,162,76,232,79,89,7,231,125,206,186,227,84,3,173,239,147,115,76,74,195,131,82,42,69,160,22,143,99,91,167,111,145,9,7,35,195,134,110,165,65,142,41,151,169,102,200,130,254,31,136,60,114,164,233,246,3,70,129,7,127,64,35,121,248,143,65,197,192,20,24,36,48,172,217,38,174,158,52,134,71,202,142,52,119,16,35,65,144,173,78,8,2,80,43,66,100,185,40,241,75,68,249,142,243,40,239,226,131,55,162,136,176,33,145,53,79,136,194,162,179,219,161,196,219,250,74,86,5,177,47,215,58,169,253,172,76,29,30,78,51,68,157,27,206,210,66,92,156,158,162,205,113,193,233,117,141,47,233,159,238,29,254,159,149,54,219,49,150,77,206,245,128,177,238,19,210,107,13,67,15,182,210,149,27,157,17,116,72,167,249,46,152,121,0,169,152,67,183,83,106,6,182,7,136,65,58,50,123,96,63,59,0,0,0,4,105,100,95,50,0,0,0,16,150,136,10,163,222,108,153,106,77,191,132,249,117,179,6,195,158,0,91,65,159,222,23,187,73,81,115,145,154,85,160,18,195,5,58,235,8,47,24,191,209,33,158,142,56,19,55,229,139,78,194,243,136,238,182,241,2,183,244,10,51,129,145,11,252,136,136,214,164,229,149,223,72,173,12,186,59,145,1,161,242,217,74,74,233,46,6,54,181,98,167,185,215,115,249,21,167,247,62,69,129,188,109,76,131,213,131,115,32,132,139,69,36,69,34,2,211,81,37,104,255,234,65,158,160,138,140,36,164,244,231,105,31,132,201,121,207,100,183,115,152,6,238,47,213,57,20,198,83,71,115,48,169,59,121,181,234,62,240,17,248,81,145,85,96,152,70,19,152,157,72,81,64,73,140,39,204,145,83,241,22,135,138,225,170,64,70,168,35,118,15,16,62,112,37,155,145,193,147,80,29,23,101,146,35,87,246,85,137,199,7,193,156,28,22,24,82,194,245,43,203,175,170,5,196,131,140,84,133,162,161,211,126,236,85,29,209,181,1,65,245,83,72,217,45,165,193,87,131,174,197,25,192,87,172,11,214,172,238,45,113,176,212,196,207,116,178,192,223,113,190,108,32,103,14,158,241,218,48,107,79,31,100,134,161,235,22,21,105,9,183,147,31,3,240,7,99,10,197,196,175,155,89,121,146,166,52,162,126,182,5,166,135,66,68,157,36,176,254,28,139,65,126,40,136,132,130,126,57,103,81,93,192,125,150,36,147,65,186,66,65,141,157,71,147,10,252,190,22,79,55,13,153,23,178,249,53,165,65,200,10,34,92,98,113,80,19,61,65,151,239,177,118,197,220,149,205,145,215,161,176,199,217,11,242,213,30,165,184,73,140,222,53,72,132,197,162,164,180,240,37,15,133,93,136,138,228,25,17,148,18,245,190,28,33,39,195,158,125,187,4,58,160,132,3,56,56,120,195,88,209,140,252,215,19,211,14,5,226,134,183,33,168,177,76,175,148,13,60,197,211,85,213,201,53,149,241,68,246,207,40,130,165,12,78,117,116,51,239,108,150,34,143,112,152,60,185,219,136,7,254,108,130,76,235,230,114,159,21,253,60,0,46,70,199,140,95,128,168,117,245,206,220,26,3,21,132,104,212,242,181,36,0,0,0,8,105,100,95,50,95,102,102,116,0,0,0,64,239,128,183,10,174,227,207,142,102,224,145,118,238,35,197,15,75,98,54,44,43,124,121,174,53,54,131,218,19,32,255,18,255,44,136,245,67,32,219,34,245,214,233,183,5,230,162,141,208,158,1,37,188,188,35,77,16,92,157,142,32,163,194,29,161,104,30,132,47,252,123,62,97,22,53,97,138,106,134,7,164,114,17,57,61,104,80,251,177,240,188,235,196,88,175,94,229,140,21,110,54,94,177,176,26,170,50,213,254,1,96,180,252,87,133,87,253,210,105,64,62,33,195,171,232,232,71,41,64,106,130,113,173,107,77,51,16,140,128,195,5,227,118,236,5,33,55,192,92,215,145,61,171,207,40,197,38,16,60,92,55,245,130,115,242,120,72,253,72,190,2,34,121,30,100,0,231,72,187,234,61,7,14,214,1,148,249,115,254,102,26,70,168,83,18,151,26,188,84,66,158,93,197,179,252,166,28,202,2,215,125,133,217,51,39,240,52,202,224,241,132,20,208,50,103,17,107,211,5,32,41,66,164,45,12,40,77,223,116,143,176,220,167,214,111,191,149,99,150,124,34,20,70,115,106,72,221,93,201,140,209,80,20,21,216,123,24,151,197,35,138,169,153,90,58,170,95,196,200,19,101,17,100,81,153,211,133,12,150,183,28,85,92,188,146,50,124,185,103,46,170,112,2,162,182,48,161,149,107,3,184,224,21,176,127,201,220,232,224,3,247,199,184,83,111,157,165,125,180,106,167,4,105,101,86,22,22,188,178,4,210,41,93,48,194,46,238,237,213,199,131,91,115,151,33,212,202,223,90,2,230,109,135,39,243,76,227,184,136,145,225,194,204,233,172,77,148,125,24,129,217,128,166,54,29,224,244,174,232,76,87,236,220,240,80,158,215,72,198,241,81,247,194,34,159,7,3,208,240,126,54,164,129,12,204,36,28,217,99,12,3,197,219,85,174,144,92,40,69,233,38,79,240,79,22,214,186,68,21,39,199,60,152,212,141,26,36,88,149,126,21,97,70,102,132,246,245,60,83,179,94,55,15,3,250,166,135,239,41,158,217,203,77,171,184,187,32,150,69,81,117,4,105,202,226,134,137,8,215,68,15,153,97,5,34,66,67,39,135,216,98,50,123,241,219,224,96,47,235,193,170,89,100,252,59,198,226,183,153,169,229,19,219,100,27,131,63,149,159,154,77,12,58,155,247,246,56,180,237,214,33,107,97,40,96,130,55,42,171,177,23,147,178,192,117,46,136,56,121,49,3,123,104,24,235,112,164,215,4,44,78,136,251,189,166,46,233,4,161,216,137,155,34,207,165,158,227,249,30,146,140,89,114,157,150,190,79,42,139,240,47,13,19,207,31,188,84,76,132,139,30,69,43,57,181,219,69,175,60,233,160,95,160,185,238,177,255,27,217,183,68,46,9,26,113,99,75,169,251,24,68,171,43,155,31,156,61,217,92,68,153,111,113,45,152,214,79,46,107,4,102,44,102,110,109,115,71,117,210,142,91,10,27,45,181,251,65,173,171,32,212,203,220,243,91,210,52,28,239,112,90,236,136,110,103,170,67,9,141,163,127,88,17,94,233,229,168,76,23,236,55,252,111,103,179,69,51,222,80,253,16,65,249,115,154,204,140,166,214,150,206,145,192,184,240,44,229,140,84,5,129,89,155,136,136,205,125,167,248,121,158,205,126,163,55,166,170,16,218,143,62,49,86,12,127,97,14,34,156,65,80,100,164,96,198,43,70,224,28,38,167,129,227,29,33,242,44,203,82,193,185,220,40,48,13,127,56,120,203,43,165,181,184,112,43,203,249,183,78,56,100,98,241,251,82,72,219,209,100,1,64,126,251,157,105,74,235,157,79,246,213,34,209,78,123,151,12,254,218,188,26,241,214,241,167,119,235,46,245,64,46,170,214,169,181,150,63,235,98,180,6,88,12,53,184,175,226,56,189,184,52,93,233,18,170,92,199,222,70,59,38,172,73,90,200,14,117,243,138,199,246,196,134,144,17,22,247,249,116,38,243,176,107,16,124,233,133,159,243,189,46,247,247,85,143,251,249,238,173,94,109,217,219,80,75,167,124,47,89,211,175,215,107,45,248,247,1,40,209,85,89,100,186,100,200,127,110,159,233,165,55,87,191,1,66,20,250,25,249,42,237,84,252,181,20,231,18,124,5,10,145,7,128,65,97,95,180,3,77,102,134,125,117,151,109,217,168,103,45,143,122,42,163,56,24,46,175,62,239,167,99,230,193,211,21,251,230,104,19,143,41,237,206,125,23,16,59,183,60,117,121,50,8,83,125,169,205,49,101,251,101,83,146,254,32,244,196,69,26,42,66,172,85,107,85,57,150,6,205,39,17,209,120,40,106,78,99,193,215,25,130,34,136,54,169,117,49,179,141,249,174,181,60,243,225,89,95,177,134,108,213,138,234,61,0,55,14,3,175,86,50,63,83,123,69,54,80,7,78,2,158,89,159,186,204,45,6,172,4,174,92,20,47,149,225,137,15,124,119,5,47,236,129,216,70,230,142,17,64,163,189,189,30,71,168,201,186,131,203,39,18,176,91,54,248,43,78,244,17,109,184,5,110,35,208,24,173,187,54,18,171,179,58,192,92,171,26,174,60,30,71,219,148,180,17,214,35,146,45,126,174,90,131,29,129,125,48,54,224,146,148,163,127,134,99,7,102,206,144,227,107,206,20,63,249,69,191,135,162,39,63,204,126,1,54,6,196,235,80,13,128,5,93,216,159,40,229,109,152,105,126,16,224,160,176,170,249,250,255,144,29,95,138,189,96,38,114,55,161,144,95,239,53,83,61,119,194,221,150,127,181,89,112,164,17,91,225,142,233,89,199,115,29,78,165,182,133,80,108,31,127,24,51,252,232,247,110,162,166,175,20,204,234,40,227,135,85,133,195,191,196,181,25,166,68,215,126,196,139,98,149,16,138,176,127,186,68,13,242,185,108,253,236,245,7,37,239,18,132,238,29,14,18,97,167,179,228,242,13,30,151,191,146,47,145,46,162,124,185,117,144,31,175,184,162,52,126,47,215,23,48,180,144,159,49,246,63,18,110,140,176,182,66,209,168,25,31,173,125,14,26,49,87,135,3,233,237,57,128,78,185,199,203,58,122,31,94,161,49,148,183,102,178,243,173,214,59,59,49,213,130,219,53,234,150,131,100,155,250,149,6,215,143,230,234,16,63,143,148,30,89,150,219,115,180,77,189,197,181,81,62,179,93,95,96,61,3,109,45,52,190,222,132,16,169,117,100,2,96,109,42,127,29,133,49,20,218,148,15,157,53,74,143,188,161,174,178,60,20,199,122,123,143,241,172,21,246,172,153,208,56,51,221,208,146,60,8,51,170,119,8,181,252,66,191,112,146,199,9,208,53,109,191,52,169,133,170,141,54,37,28,88,9,190,168,50,184,114,55,117,150,184,197,90,65,10,52,22,128,108,12,141,46,226,28,152,185,50,16,166,202,93,174,18,112,66,153,133,72,220,106,73,78,132,155,208,105,63,76,246,195,124,249,44,62,64,187,62,194,125,195,102,77,227,106,127,109,226,252,79,48,53,156,148,214,95,138,224,249,83,23,191,4,219,208,31,138,193,10,22,73,230,130,112,81,47,236,238,147,104,209,77,86,130,95,150,53,30,81,51,202,50,150,68,195,28,8,216,87,124,236,159,18,182,56,236,114,184,79,247,51,229,65,77,229,60,171,142,242,111,77,10,236,60,236,142,143,36,91,219,194,145,107,224,169,161,231,189,253,149,143,107,196,89,72,29,168,43,39,1,214,66,163,119,10,93,225,116,116,58,193,26,125,21,90,218,60,251,5,100,152,242,199,93,207,200,233,112,221,20,8,177,29,45,225,29,81,67,47,7,70,239,19,207,197,29,187,109,99,140,134,129,240,157,110,72,66,94,138,15,162,201,149,13,22,69,0,145,214,35,187,216,156,121,139,216,92,50,26,32,132,122,192,4,185,211,22,216,175,248,213,132,242,131,12,77,150,176,227,108,67,27,124,56,151,142,179,156,82,153,177,247,62,116,42,196,150,43,160,46,26,215,64,192,46,202,51,14,59,40,111,241,125,36,123,190,243,117,168,40,136,231,108,178,48,141,87,11,45,139,223,150,6,156,109,3,153,163,138,204,137,152,231,21,86,52,5,143,195,249,126,74,187,92,208,22,1,141,187,19,226,97,45,161,14,155,137,88,222,245,146,227,159,90,236,116,53,55,248,5,241,183,236,237,13,176,51,226,229,183,123,34,181,143,139,23,146,27,142,214,109,165,52,203,87,175,225,1,178,91,207,228,136,170,181,116,241,52,208,241,233,240,69,205,244,67,173,137,239,138,59,230,201,136,242,48,239,224,57,91,51,80,181,209,181,192,44,131,205,5,254,148,225,184,245,172,155,197,247,176,250,167,109,247,176,39,31,44,222,129,94,140,217,36,41,117,18,242,115,187,152,173,21,32,246,176,213,52,152,131,103,50,134,166,53,134,73,114,154,93,164,109,189,125,62,48,123,144,236,18,142,29,27,13,236,24,38,245,168,210,65,225,200,166,214,195,180,24,123,40,249,146,174,161,73,149,69,73,0,0,0,13,105,100,95,50,95,108,97,103,114,97,110,103,101,0,0,0,16,230,255,255,159,249,14,13,27,63,145,42,163,163,104,186,234,137,6,221,216,118,235,216,71,195,187,245,32,85,8,208,21,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,204,201,111,205,99,99,197,113,236,96,168,124,216,161,239,22,107,170,143,84,86,69,161,143,147,167,34,168,75,227,143,27,179,173,80,90,166,93,194,109,93,19,128,143,189,210,107,59,179,188,41,62,133,213,53,227,102,171,254,155,62,46,132,22,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,188,113,226,162,129,165,213,150,142,207,49,105,2,250,104,204,144,24,245,231,233,199,163,227,123,25,56,45,188,66,129,42,27,0,0,80,154,230,212,40,82,223,142,214,164,127,121,61,211,81,164,168,63,90,119,112,102,228,59,192,29,70,148,26,244,52,18,139,77,109,21,4,179,69,26,122,139,211,19,112,3,84,155,248,119,32,116,104,132,175,5,134,191,28,192,32,202,146,156,35,118,85,7,120,27,150,165,205,108,166,31,230,253,231,161,179,183,106,62,90,127,224,241,39,186,23,179,60,53,54,144,34,48,146,28,210,164,15,17,253,111,70,68,17,242,173,241,44,96,0,175,40,150,248,14,57,39,107,212,20,78,82,175,149,237,151,31,214,51,93,57,234,138,21,200,236,169,155,87,67,49,112,26,213,194,244,50,69,52,32,224,25,130,169,204,189,78,168,55,116,47,241,241,103,142,74,27,202,223,50,104,211,20,31,196,11,137,179,83,159,252,91,199,25,6,25,45,100,193,5,69,182,91,74,53,69,246,35,191,46,189,254,63,240,167,225,37,123,138,182,127,28,105,68,233,44,70,142,29,61,166,69,238,240,147,17,65,138,142,214,254,131,41,152,13,27,131,195,252,140,215,38,43,149,41,90,71,54,0,0,0,4,105,100,95,51,0,0,0,16,81,10,115,192,155,197,30,205,74,100,175,47,183,134,184,114,46,45,88,160,43,248,147,185,76,181,204,69,115,113,21,46,191,5,58,43,185,88,144,175,140,95,184,167,22,114,103,68,23,237,188,237,174,215,117,16,92,54,46,134,103,71,0,10,46,113,61,110,87,177,140,87,29,214,145,174,42,30,237,125,151,72,89,37,2,182,77,42,47,3,181,132,110,56,3,7,167,247,62,69,129,188,109,76,131,213,131,115,32,132,139,69,36,69,34,2,211,81,37,104,255,234,65,158,160,138,140,36,9,129,249,55,202,23,34,242,238,60,184,222,182,68,76,34,123,35,40,244,77,144,120,5,22,172,59,219,82,59,209,5,233,239,108,207,251,131,192,169,133,5,204,185,10,181,96,4,55,62,68,175,65,153,34,46,181,197,11,59,31,200,80,35,126,83,147,128,131,74,165,72,93,226,41,173,71,146,111,170,99,172,214,129,107,113,7,205,12,246,109,40,136,37,40,26,196,131,140,84,133,162,161,211,126,236,85,29,209,181,1,65,245,83,72,217,45,165,193,87,131,174,197,25,192,87,172,11,103,207,132,109,157,162,107,171,66,15,177,155,151,192,115,122,71,157,42,10,151,197,93,245,86,210,7,65,17,11,161,15,105,9,183,147,31,3,240,7,99,10,197,196,175,155,89,121,146,166,52,162,126,182,5,166,135,66,68,157,36,176,254,28,13,181,202,51,236,109,111,189,244,254,162,87,216,206,67,138,55,112,146,156,246,1,173,202,14,83,241,132,55,79,46,6,153,23,178,249,53,165,65,200,10,34,92,98,113,80,19,61,65,151,239,177,118,197,220,149,205,145,215,161,176,199,217,11,65,165,14,122,36,107,23,29,166,48,90,73,139,68,239,64,201,194,87,100,92,61,54,188,153,12,83,96,14,229,64,29,209,0,162,81,213,88,68,170,132,95,251,149,176,4,201,135,52,211,161,147,45,173,249,129,131,252,176,61,222,14,239,9,72,134,100,205,204,139,64,230,33,185,90,198,253,104,147,117,42,243,190,61,82,28,78,246,222,83,29,175,68,161,10,9,254,108,130,76,235,230,114,159,21,253,60,0,46,70,199,140,95,128,168,117,245,206,220,26,3,21,132,104,212,242,181,36,0,0,0,8,105,100,95,51,95,102,102,116,0,0,0,64,34,213,255,253,215,182,91,175,210,248,73,143,209,241,197,211,193,112,239,120,44,52,149,137,121,214,24,2,2,160,234,51,149,25,37,47,203,115,187,150,255,227,46,204,155,171,7,95,140,49,188,252,1,16,101,151,50,197,242,86,0,117,203,17,77,171,238,173,77,163,124,18,108,187,248,66,50,68,85,131,74,139,41,190,206,26,202,178,179,246,194,41,28,158,43,16,183,150,102,246,45,138,206,11,128,2,216,233,218,31,66,53,23,29,228,218,41,137,242,24,228,6,187,78,192,146,182,95,149,162,152,71,251,72,205,26,214,151,119,146,234,140,160,84,132,53,159,20,124,155,53,110,112,140,18,205,189,232,20,76,62,215,140,142,19,230,147,1,36,154,129,187,120,192,208,135,71,127,153,97,208,41,224,249,190,250,181,6,59,103,130,27,90,6,55,238,124,42,164,174,222,66,157,91,107,76,141,133,45,22,48,200,180,138,26,249,165,162,58,178,241,149,128,5,232,214,194,154,17,67,185,244,144,231,109,128,121,56,11,97,178,215,101,73,179,123,35,185,167,157,134,123,29,152,176,3,65,208,233,150,18,22,196,228,193,157,60,31,216,248,152,118,89,98,85,247,59,42,239,89,59,15,61,153,140,116,57,45,49,215,229,40,194,63,59,28,17,29,189,148,253,25,15,219,193,162,51,93,29,124,207,184,160,39,16,123,172,89,27,94,159,98,160,202,62,133,39,79,252,114,0,246,14,105,110,67,63,60,105,58,87,55,21,231,123,7,81,220,56,53,186,37,71,164,197,113,74,1,110,246,186,217,61,93,210,18,70,138,17,160,212,151,171,11,119,206,24,14,198,35,17,19,153,0,42,213,48,28,16,102,107,167,41,38,87,165,21,198,9,57,231,64,74,63,98,0,69,133,66,57,156,28,209,22,87,35,19,124,99,147,93,237,103,141,191,247,126,216,88,29,227,200,193,135,229,225,246,215,218,176,191,76,96,77,98,26,66,64,178,107,27,45,203,79,244,9,207,210,168,2,209,9,63,227,57,216,244,69,156,245,157,229,90,177,134,49,147,72,147,94,25,121,42,49,11,144,147,149,166,124,42,2,51,240,222,200,76,71,213,62,244,249,187,138,71,208,6,65,153,155,21,45,239,144,3,187,135,161,37,114,45,91,83,213,35,227,241,44,188,63,49,206,55,119,65,143,138,209,150,219,21,3,25,9,165,134,71,13,78,240,160,23,160,135,180,208,221,129,190,206,234,212,80,181,102,93,102,227,50,205,21,159,186,157,231,18,239,183,52,92,179,159,227,76,153,31,232,55,107,144,37,51,25,124,44,163,53,251,47,187,211,71,83,66,6,57,230,44,82,205,98,2,214,199,227,207,87,46,254,41,7,117,71,82,214,192,2,165,183,203,124,237,197,209,8,87,137,211,248,69,167,191,144,185,127,197,196,180,93,45,101,126,96,190,244,210,121,48,229,115,146,245,218,67,164,221,244,158,39,63,196,51,46,68,241,115,60,39,92,190,174,142,147,205,181,14,228,6,1,213,88,201,83,134,58,120,121,252,105,115,207,6,42,68,193,37,1,66,184,127,125,20,127,17,106,72,124,55,67,249,79,122,204,102,64,163,42,172,141,186,228,44,29,116,155,0,45,80,146,140,34,55,133,173,21,12,227,211,17,152,176,103,251,129,159,92,105,127,94,25,186,155,61,194,26,188,217,29,18,89,171,43,9,6,26,73,155,3,17,8,225,29,237,98,96,115,78,185,173,236,137,99,213,208,151,189,248,241,59,76,70,67,80,89,96,65,180,247,180,84,173,5,109,76,138,84,142,68,49,96,81,196,231,138,244,90,5,21,116,16,245,82,140,221,182,243,36,4,100,148,178,138,140,231,173,153,161,62,30,116,163,125,177,44,225,239,43,27,219,99,178,63,132,51,34,32,225,94,42,188,59,220,104,129,30,190,192,50,184,130,206,179,176,15,168,153,77,115,7,182,15,63,219,183,174,60,142,242,75,147,241,8,248,214,144,167,52,151,6,144,253,100,243,183,247,233,192,7,131,234,5,16,213,43,63,0,110,80,53,128,135,253,68,73,13,199,242,70,155,166,33,138,39,159,18,183,104,46,57,93,248,222,176,178,50,68,76,2,2,46,150,19,76,139,223,163,217,157,227,120,193,151,252,160,243,122,84,113,74,10,77,90,8,158,220,235,82,1,184,125,53,54,222,213,222,214,119,237,71,97,164,248,178,92,236,75,231,253,138,238,60,54,101,95,119,82,123,62,242,190,74,18,239,81,178,206,181,154,48,234,11,65,52,248,124,111,59,64,140,64,158,86,39,171,47,165,242,53,200,58,156,219,239,187,220,30,75,142,29,114,70,251,226,176,87,16,123,231,212,24,238,152,96,26,208,117,160,227,211,236,135,135,100,86,123,245,53,83,165,247,21,120,116,3,67,173,142,234,99,183,184,33,138,77,112,8,86,204,147,198,44,247,16,55,32,65,194,233,156,23,21,209,36,192,8,170,223,45,120,224,21,29,49,79,219,221,73,213,44,102,1,225,227,103,11,77,110,167,72,38,184,30,211,154,193,28,2,146,52,48,44,190,59,103,18,181,28,154,3,38,71,202,169,109,215,175,11,248,79,173,98,252,79,41,4,17,18,225,124,39,235,182,125,60,203,22,23,65,79,211,150,174,176,11,225,30,179,148,125,127,99,4,123,68,95,82,162,168,141,181,218,161,122,91,244,45,60,3,113,156,163,96,58,200,41,2,245,211,72,164,195,60,85,29,103,220,135,15,70,197,47,118,186,67,98,244,85,2,37,22,112,118,80,139,208,24,196,153,27,220,71,79,66,189,12,12,212,116,177,40,179,25,252,214,135,157,251,65,187,157,140,95,190,12,131,30,239,158,123,42,93,66,200,72,88,105,98,75,42,54,155,2,103,130,57,206,163,193,13,43,13,213,238,157,255,120,199,134,47,37,126,61,1,23,97,69,95,128,113,219,194,77,93,78,225,7,41,58,65,137,69,167,25,77,21,151,121,161,48,196,188,144,92,185,150,11,188,170,50,90,233,59,202,89,146,26,37,113,189,98,42,94,1,237,235,103,112,25,142,102,177,156,100,1,94,18,166,214,83,254,69,142,182,190,44,103,27,6,166,10,206,254,15,153,251,114,15,126,139,1,38,178,167,125,14,112,169,179,124,105,227,62,89,169,197,26,15,216,238,36,255,0,138,99,101,161,16,42,242,41,31,73,65,236,148,53,9,218,51,171,66,154,174,169,198,22,76,77,14,207,11,91,212,222,114,26,105,107,227,92,90,236,60,139,167,233,106,251,250,78,219,95,35,25,82,46,100,83,78,12,30,172,26,33,11,109,157,131,32,13,133,45,130,107,136,22,253,206,73,202,149,23,45,181,112,101,66,180,94,215,161,166,135,168,195,75,127,41,39,229,112,185,21,197,54,107,10,154,85,132,136,200,129,66,236,47,70,143,134,170,121,165,120,147,140,30,69,23,195,96,79,240,126,99,50,25,107,231,254,22,78,84,141,80,155,95,191,24,87,124,247,188,244,208,208,221,110,75,232,5,215,35,105,221,33,80,222,253,58,47,161,236,177,64,141,223,111,121,4,107,100,147,223,146,227,188,131,159,188,224,245,65,180,207,129,14,0,51,204,104,207,137,23,187,252,57,155,213,109,158,234,208,158,30,178,59,227,175,162,130,15,208,201,83,41,179,224,42,97,228,131,38,64,174,41,42,87,57,164,247,178,234,212,185,176,242,113,78,112,112,206,25,247,33,229,4,100,118,59,36,59,63,20,167,183,8,155,149,156,10,134,122,192,218,90,226,77,2,155,151,175,72,79,118,217,4,96,66,165,89,158,247,167,201,38,22,198,56,100,170,182,173,182,87,142,195,159,194,158,227,72,26,232,248,108,148,91,19,162,86,185,54,245,178,144,189,174,67,155,212,176,126,243,170,237,225,179,179,253,0,31,16,19,248,244,150,55,80,221,167,239,40,248,46,238,122,204,121,104,63,238,141,155,228,205,143,73,127,186,69,15,225,75,169,46,159,96,104,86,125,177,84,21,91,182,36,175,44,121,216,63,80,214,51,40,99,202,7,225,55,29,161,229,200,80,23,251,187,159,36,78,29,5,236,60,16,82,111,138,88,166,172,163,69,115,65,23,144,89,194,107,79,216,4,27,107,193,65,5,222,34,158,81,193,132,70,112,21,10,125,122,147,51,113,255,71,165,242,159,179,19,187,148,247,195,29,133,181,96,143,169,34,19,56,181,37,81,197,4,62,58,82,186,194,90,157,93,227,208,66,2,65,176,220,99,213,71,239,147,61,68,61,122,155,137,85,28,90,224,114,73,80,29,180,247,174,221,5,80,61,57,82,72,173,37,220,170,76,206,15,163,50,173,188,235,56,95,237,204,90,86,182,176,87,122,226,68,198,229,163,189,53,90,239,148,108,197,154,25,209,38,158,106,233,89,135,17,187,131,67,61,64,56,87,127,62,144,14,193,156,185,151,51,89,115,72,249,199,34,233,57,136,153,154,21,116,188,124,37,225,254,128,17,5,211,251,201,9,0,0,0,13,105,100,95,51,95,108,97,103,114,97,110,103,101,0,0,0,16,225,255,255,239,21,67,163,199,104,94,139,66,57,223,182,33,184,76,86,81,230,142,71,174,242,154,253,186,22,128,218,35,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,91,37,134,198,243,18,38,174,254,144,62,125,40,250,225,121,7,238,248,177,220,222,23,33,15,169,31,3,119,103,101,23,61,157,45,9,170,165,85,169,236,51,14,199,161,1,119,114,196,208,177,48,72,242,150,184,12,20,142,244,0,91,87,17,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,198,255,255,159,123,92,206,158,22,127,252,107,148,95,61,228,228,250,177,168,166,52,208,61,140,182,193,250,248,57,70,9,174,187,15,253,249,253,165,102,215,152,241,179,178,104,156,75,85,45,191,21,54,7,62,148,29,120,47,220,179,48,166,31,33,0,0,240,17,168,32,192,185,130,231,176,87,241,176,46,2,100,172,177,134,252,88,194,96,165,101,7,207,28,238,60,242,165,226,6,101,229,64,83,119,77,3,144,247,141,44,48,246,84,33,94,63,169,222,147,175,18,129,148,224,65,168,58,139,22,239,109,147,10,90,127,92,16,218,73,109,223,190,184,6,190,13,86,140,109,199,128,213,6,87,232,210,154,114,24,166,218,121,41,160,226,187,149,146,223,122,252,31,238,81,174,85,106,136,207,217,102,56,151,26,247,17,222,251,230,254,24,196,98,210,230,233,79,140,154,164,60,171,178,166,230,188,181,152,135,207,80,110,83,185,255,28,140,163,236,113,243,12,31,208,49,143,112,110,142,247,244,121,123,131,68,75,19,23,121,189,131,228,254,170,246,145,161,146,87,191,217,87,224,165,69,161,183,207,65,159,209,76,232,87,9,101,107,156,89,137,166,245,220,153,160,135,233,163,184,225,199,60,79,200,97,146,63,84,68,240,226,45,237,29,33,75,72,129,63,222,103,203,4,101,131,67,237,54,132,98,220,53,200,51,230,49,108,34,65,0,0,0,4,105,100,95,52,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,219,255,255,79,158,129,87,48,1,187,50,104,134,109,127,48,137,58,78,72,159,236,101,92,248,217,211,115,101,169,128,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,240,147,245,225,67,145,112,185,121,72,232,51,40,93,88,129,129,182,69,80,184,41,160,49,225,114,78,100,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,105,100,95,52,95,102,102,116,0,0,0,64,71,255,255,143,23,136,181,241,5,167,253,8,160,35,125,242,173,36,135,105,28,159,253,205,217,65,35,67,251,78,131,7,2,93,154,102,198,161,219,84,71,245,123,124,140,164,209,251,233,17,138,244,207,75,189,6,217,97,118,148,162,74,48,43,141,113,239,24,99,32,129,112,131,150,79,14,200,174,198,187,196,103,13,121,246,177,88,13,123,130,49,210,95,221,159,22,65,194,17,224,192,221,54,103,202,117,28,67,104,217,130,77,198,0,131,231,216,96,84,114,252,109,39,46,189,48,16,24,89,141,128,226,196,206,211,54,241,74,231,9,154,192,120,184,185,109,71,187,72,121,100,190,49,84,208,187,1,191,180,12,15,29,228,31,47,5,61,54,17,52,5,235,70,40,0,197,5,56,245,185,48,112,241,224,59,203,123,49,241,17,218,45,37,101,14,144,234,222,182,221,121,184,129,142,112,31,2,192,235,29,177,219,53,14,88,103,172,9,37,179,157,144,166,35,58,35,217,121,208,64,76,188,173,26,248,82,5,7,103,103,61,17,179,75,139,14,219,79,252,192,4,61,108,103,125,27,131,252,183,118,248,75,190,26,91,218,253,167,146,157,245,30,85,195,30,164,100,136,29,3,252,125,33,211,242,27,161,10,202,37,178,130,118,95,102,21,186,154,80,161,66,153,31,171,150,183,178,114,78,104,137,251,67,138,57,68,166,218,158,30,147,30,121,165,98,28,188,47,105,122,40,127,217,202,241,30,215,151,88,134,49,103,198,161,90,91,153,75,182,95,112,48,245,180,225,172,188,66,106,99,236,244,25,97,52,57,21,16,199,176,76,152,194,42,65,253,110,229,128,241,150,32,67,40,145,132,14,206,254,214,191,80,195,84,110,251,17,180,241,39,214,159,105,203,56,20,120,196,139,180,93,245,184,75,194,47,10,164,206,59,226,15,214,108,95,80,95,137,106,211,69,123,124,56,172,118,232,3,49,42,89,109,175,227,233,209,126,26,15,66,46,155,22,182,147,91,95,32,31,100,139,118,60,147,148,5,62,156,79,91,169,152,199,7,11,168,80,21,116,48,230,45,42,254,45,82,54,17,5,7,80,240,181,83,134,123,53,248,108,235,40,92,139,195,231,109,247,56,215,250,28,26,226,191,52,168,208,174,170,52,218,53,84,127,85,10,87,39,207,31,160,46,129,5,136,13,83,207,97,160,93,88,112,12,136,181,75,36,109,73,47,48,96,250,21,135,63,14,183,225,30,68,83,218,156,90,52,78,140,57,134,226,96,93,44,33,12,226,60,249,92,175,217,182,55,0,101,154,61,176,164,28,24,132,228,217,172,205,219,129,60,68,190,109,217,41,212,41,103,26,254,19,254,210,234,147,127,14,142,241,36,38,102,168,83,253,151,9,21,37,203,142,219,205,51,7,22,20,213,45,118,93,103,143,40,60,2,226,248,41,72,15,61,151,16,26,86,253,43,62,72,61,228,142,231,151,124,41,227,181,29,13,41,10,2,65,118,221,96,76,208,167,121,41,14,39,207,85,104,53,202,194,227,181,228,147,199,177,251,37,155,69,94,44,164,196,172,54,9,42,154,214,88,241,231,20,50,246,24,49,8,120,33,152,255,119,2,234,105,10,132,48,5,49,16,20,111,119,245,139,247,118,105,194,164,74,238,167,92,222,97,1,109,4,3,170,167,162,171,12,150,149,19,77,44,28,174,27,221,80,196,210,193,142,74,223,118,11,157,111,63,94,49,210,95,115,201,248,101,188,40,172,90,99,221,96,68,70,93,24,140,178,63,0,88,181,131,138,84,160,245,239,249,166,34,131,6,146,124,139,219,66,23,239,68,189,63,193,198,10,46,13,60,215,19,142,170,164,78,255,101,21,136,134,127,82,66,162,182,20,25,174,39,231,11,12,240,251,157,16,237,194,207,39,4,148,57,145,6,26,158,254,240,74,87,75,101,221,113,138,193,88,224,7,227,128,119,171,62,61,140,133,127,37,142,47,30,28,49,212,19,197,139,136,126,9,4,6,94,100,167,165,198,153,171,78,30,213,152,231,104,241,94,245,115,252,46,7,139,234,70,127,44,162,136,40,72,123,177,184,119,175,249,219,76,108,9,161,151,31,238,138,119,181,203,147,71,182,219,14,135,154,166,203,230,251,214,199,24,37,157,209,108,0,254,175,29,173,82,132,112,200,72,87,46,94,62,200,102,83,194,11,253,133,240,112,234,61,148,117,220,121,94,187,59,230,250,130,40,93,245,47,234,150,165,181,71,86,143,247,11,79,144,18,187,0,0,80,16,99,14,150,28,58,117,234,240,172,234,93,12,140,123,153,80,236,162,162,121,254,63,127,234,77,69,89,0,163,101,121,97,73,232,50,219,235,246,118,4,44,150,84,208,158,120,14,157,63,227,105,122,222,236,45,67,82,152,53,117,142,16,199,196,202,66,23,159,74,35,229,200,33,161,148,245,72,245,137,118,217,71,99,216,189,49,240,133,191,40,74,193,61,238,255,102,13,141,32,88,107,86,176,40,247,228,2,244,175,127,27,148,42,76,254,86,210,59,148,40,108,184,72,169,114,127,253,98,28,240,80,49,150,139,233,246,15,239,151,0,67,187,71,36,18,60,178,33,236,146,6,228,221,19,84,243,226,27,192,248,229,134,81,17,173,109,8,74,168,103,139,180,120,13,73,60,27,175,143,23,117,231,144,244,138,238,50,221,154,241,79,61,12,13,170,168,40,241,100,32,177,101,144,206,146,81,39,55,125,72,9,167,54,62,15,72,12,34,61,200,220,38,102,87,170,119,203,116,198,122,160,139,201,0,233,124,159,79,183,225,124,197,32,87,127,94,133,121,53,75,69,127,3,72,105,47,159,5,109,199,6,117,75,254,50,114,49,101,237,227,94,8,3,131,109,87,194,65,239,242,128,39,86,56,218,77,93,177,139,93,114,104,70,34,82,78,55,72,165,35,249,79,144,30,35,23,117,15,182,41,126,63,194,41,66,111,225,134,58,197,206,7,88,185,102,74,116,183,5,118,49,227,24,170,124,59,36,218,206,248,228,201,118,47,61,88,48,13,75,30,51,107,168,89,36,54,236,88,146,92,151,82,64,243,255,181,106,170,96,95,115,228,90,226,208,78,124,133,56,113,123,241,17,41,20,4,55,95,140,4,248,126,28,118,40,228,16,153,55,52,119,40,172,199,139,5,205,44,81,6,49,248,91,49,164,69,219,237,26,195,144,19,106,38,253,33,213,61,120,86,140,132,135,111,70,250,210,179,222,251,202,73,70,243,189,209,68,17,53,48,44,195,192,83,143,5,90,43,189,37,171,196,102,29,48,247,215,139,56,88,26,149,135,84,48,28,210,213,225,249,152,141,118,29,218,34,3,219,124,225,212,132,184,149,23,68,47,21,173,107,210,107,137,14,162,171,70,32,64,203,55,87,60,25,83,72,171,30,116,59,198,16,41,235,144,98,212,235,133,24,99,0,113,1,34,136,68,88,84,122,74,180,187,186,161,148,87,194,230,92,108,81,194,176,110,155,108,175,40,208,48,108,34,199,6,221,223,132,63,156,63,246,29,195,230,202,59,234,208,234,224,13,89,83,32,195,51,162,44,30,41,192,189,196,238,22,252,164,84,12,115,244,54,155,229,1,204,41,24,217,243,162,210,228,1,108,170,1,168,102,179,106,249,87,102,213,225,119,114,47,187,207,136,243,50,140,162,152,80,255,174,193,165,41,183,42,228,83,57,87,54,100,179,214,196,36,78,188,225,107,168,230,152,2,231,170,83,217,245,253,158,177,13,99,59,82,57,249,201,130,169,152,250,81,123,56,64,137,213,187,220,139,142,103,156,74,87,106,52,94,59,83,169,30,193,41,177,201,239,138,222,94,218,78,31,178,56,225,106,109,19,158,134,233,53,223,145,224,107,184,76,147,136,10,84,48,116,90,197,125,150,132,75,52,242,5,79,77,172,255,88,197,232,244,99,189,170,79,117,185,128,26,69,37,175,59,13,102,92,121,168,171,213,213,131,81,114,54,126,90,61,57,10,7,207,119,196,248,220,133,97,161,86,107,72,118,77,192,223,207,53,64,253,205,64,125,3,151,41,69,205,179,30,134,119,145,72,137,129,14,131,35,1,31,146,154,83,198,40,236,81,125,70,117,136,188,203,234,108,17,126,37,174,3,156,233,84,69,164,148,100,99,68,197,177,248,217,248,56,254,107,198,78,33,209,37,137,49,150,27,168,43,243,245,197,248,87,34,251,137,10,41,197,20,3,215,60,102,119,58,49,228,227,206,11,20,38,56,255,163,215,110,237,50,108,192,170,243,22,87,180,78,182,7,137,234,78,4,205,113,160,153,89,119,21,185,96,251,72,59,95,218,101,193,58,25,33,110,116,109,68,249,97,213,107,178,229,219,138,151,46,158,230,236,81,123,101,89,20,65,239,236,191,9,188,213,33,36,208,105,160,156,3,176,126,252,194,87,25,37,226,36,250,126,73,6,85,5,122,15,111,61,173,47,18,70,103,20,56,85,234,108,205,145,83,13,211,130,244,250,186,11,234,211,202,217,77,56,78,0,0,0,13,105,100,95,52,95,108,97,103,114,97,110,103,101,0,0,0,16,219,255,255,79,158,129,87,48,1,187,50,104,134,109,127,48,137,58,78,72,159,236,101,92,248,217,211,115,101,169,128,1,18,233,76,93,171,141,87,229,230,139,134,77,45,136,34,96,209,90,91,63,102,89,87,177,120,202,102,31,228,53,56,12,180,101,190,71,79,64,83,121,98,117,241,57,146,231,161,116,240,107,134,7,159,143,175,88,212,210,67,87,20,226,205,11,234,128,156,191,131,194,134,234,16,193,212,125,120,82,212,220,163,49,98,15,99,120,142,178,138,170,28,94,162,235,58,19,199,140,10,184,173,237,232,228,123,84,156,254,133,48,130,169,213,228,57,35,11,15,248,141,178,124,29,77,195,135,42,12,229,69,174,172,45,108,238,85,239,75,23,76,209,220,136,80,124,52,35,90,226,2,145,241,224,228,105,143,165,134,168,31,198,169,141,192,170,77,111,109,206,24,222,97,78,65,20,50,140,245,14,178,5,154,126,122,26,103,105,64,190,29,141,14,160,5,61,87,114,86,118,54,32,98,177,254,98,215,207,202,25,66,137,67,130,70,216,68,191,214,38,139,171,30,203,20,38,0,0,160,245,115,138,19,144,181,134,17,194,122,180,247,211,29,51,57,23,89,234,91,49,198,93,109,13,165,227,46,239,22,179,146,232,103,138,94,170,228,50,44,27,96,17,200,139,253,37,66,80,236,248,6,177,213,202,193,142,24,44,36,77,154,65,168,68,181,142,202,46,251,199,63,182,0,146,179,108,236,250,121,23,182,160,95,85,205,237,137,94,108,150,36,23,127,99,48,16,51,91,89,128,175,228,251,207,149,95,75,185,38,31,114,83,205,193,5,159,245,20,131,208,98,41,29,58,115,245,55,230,7,249,94,21,28,29,123,194,183,177,126,135,115,71,94,171,54,88,42,119,35,20,148,175,198,57,36,28,186,81,67,102,137,243,237,161,36,162,45,119,11,171,215,224,35,94,39,212,66,191,198,72,187,199,81,205,199,187,16,59,86,114,47,233,167,114,214,194,87,219,23,250,166,31,246,208,98,114,207,176,171,209,61,15,57,200,160,180,48,215,33,97,250,194,152,33,159,107,13,113,14,8,123,229,16,100,93,67,22,248,61,52,255,119,115,106,201,10,86,199,47,153,27,0,0,0,0,0,0,0,0,0,0,0,0,0],"verification_key":[0,0,0,2,0,0,0,16,0,0,0,0,0,0,0,23,0,0,0,4,73,68,95,49,20,49,49,179,12,40,156,67,239,232,192,60,207,165,125,56,234,109,137,210,58,227,28,229,113,75,197,218,168,106,118,142,13,192,44,120,142,211,61,165,182,104,114,235,249,88,92,141,122,188,18,1,205,106,171,211,81,16,126,56,63,147,205,25,0,0,0,4,73,68,95,50,16,10,73,113,157,83,107,100,184,223,158,5,39,248,52,205,186,193,200,45,174,64,92,152,107,137,91,238,31,26,95,127,23,203,156,211,170,18,143,125,129,57,31,10,14,41,78,37,236,111,70,47,21,23,211,58,187,241,102,166,83,8,0,217,0,0,0,4,73,68,95,51,43,202,144,96,224,0,83,238,84,20,36,120,164,118,157,225,218,57,5,32,64,106,223,171,38,240,66,41,186,158,47,146,26,64,232,125,119,70,91,3,93,140,174,66,227,136,72,159,215,222,73,255,126,254,118,41,247,125,250,215,95,10,80,132,0,0,0,4,73,68,95,52,46,234,100,140,135,50,89,107,19,20,254,42,77,47,5,54,63,12,153,78,145,206,202,210,88,53,51,142,222,226,41,79,10,180,152,134,194,185,75,208,189,63,110,209,219,190,44,178,103,29,42,229,29,49,193,33,4,51,195,151,43,182,69,120,0,0,0,3,81,95,49,17,6,177,58,190,50,155,216,217,204,157,44,38,98,209,188,147,72,214,64,225,47,196,203,134,200,239,193,35,83,200,124,0,151,151,74,98,154,19,122,227,132,196,28,91,51,187,224,199,208,219,86,44,248,10,45,0,91,175,105,0,76,80,224,0,0,0,3,81,95,50,11,179,73,194,52,84,255,76,100,220,198,200,195,79,126,184,253,168,129,202,234,240,9,67,198,81,215,253,244,134,246,229,9,112,67,97,123,110,149,178,1,76,151,252,222,99,33,165,184,102,181,73,19,200,56,79,46,254,157,40,209,127,48,75,0,0,0,3,81,95,51,10,205,230,201,195,86,211,30,31,11,118,99,63,185,237,42,175,255,250,203,54,114,46,10,202,57,105,201,0,17,21,133,29,33,237,17,42,61,17,54,236,88,93,39,202,111,155,250,58,42,154,151,126,214,164,84,166,202,180,8,55,94,142,190,0,0,0,3,81,95,52,2,214,253,158,132,219,231,75,117,49,225,128,20,5,161,194,146,17,123,26,23,254,254,157,224,191,217,237,241,168,75,249,41,60,106,179,192,106,6,105,175,19,57,58,130,198,10,69,154,59,42,11,118,141,164,90,199,175,127,42,236,64,252,66,0,0,0,12,81,95,65,82,73,84,72,77,69,84,73,67,21,117,73,158,206,175,178,185,32,253,18,117,203,174,240,27,101,142,44,200,94,145,166,118,174,247,207,210,94,132,179,216,19,205,139,201,233,65,52,30,115,10,15,92,236,197,65,191,84,239,217,8,59,22,154,67,4,24,116,58,219,123,89,226,0,0,0,5,81,95,65,85,88,21,90,15,81,254,199,140,51,255,206,183,54,77,105,215,172,39,229,112,174,80,188,24,5,9,118,78,179,254,249,72,21,28,28,71,32,190,212,74,89,29,151,203,199,43,110,68,182,68,153,151,19,168,211,198,110,144,84,170,87,38,50,76,118,0,0,0,3,81,95,67,29,39,169,134,181,204,152,42,167,195,70,120,27,109,4,246,159,247,84,178,54,108,25,0,203,224,231,232,76,172,239,237,23,87,44,72,240,224,111,147,47,192,204,255,209,89,200,28,140,119,29,102,48,85,159,71,78,77,188,19,247,10,90,81,0,0,0,10,81,95,69,76,76,73,80,84,73,67,10,211,75,94,141,183,42,90,207,68,39,84,108,114,148,190,110,212,244,210,82,167,144,89,229,5,249,171,193,189,243,237,30,91,38,121,10,38,235,52,2,23,221,154,210,141,191,144,160,73,244,42,56,82,172,212,94,111,82,31,36,180,144,14,0,0,0,3,81,95,77,35,138,46,11,151,121,7,27,160,31,103,97,76,21,77,4,141,192,51,165,254,115,2,194,153,213,83,210,5,184,25,132,1,182,212,122,27,243,20,18,53,23,24,27,222,45,237,213,196,85,215,172,85,209,217,65,23,225,47,80,98,152,61,34,0,0,0,6,81,95,83,79,82,84,44,188,231,190,238,48,118,183,141,172,224,73,67,214,157,13,158,40,170,109,0,224,70,133,39,129,165,242,8,22,100,92,43,194,126,194,225,97,46,162,132,176,139,204,85,182,242,253,145,93,17,191,237,189,192,229,157,224,158,91,40,149,32,128,0,0,0,7,83,73,71,77,65,95,49,43,90,227,204,129,65,188,154,155,46,76,69,134,126,153,33,167,33,20,80,94,233,153,240,161,200,127,247,94,247,80,123,42,218,250,131,76,239,152,182,154,45,139,63,250,79,108,104,31,249,163,28,78,161,171,92,176,121,207,152,170,154,168,193,0,0,0,7,83,73,71,77,65,95,50,42,156,121,156,239,126,82,19,132,22,151,51,129,134,245,1,150,87,113,70,135,150,150,28,132,199,148,142,42,169,207,43,6,218,61,216,5,223,113,238,102,96,230,96,163,157,71,50,141,237,222,74,220,107,26,198,111,70,252,227,151,107,139,116,0,0,0,7,83,73,71,77,65,95,51,5,103,47,224,134,19,76,147,223,227,161,72,230,3,212,9,139,54,245,151,71,224,53,22,140,111,179,202,118,63,102,49,23,138,85,224,7,117,190,57,162,221,182,96,198,73,57,186,144,8,75,30,85,169,79,107,76,117,185,76,22,201,22,51,0,0,0,7,83,73,71,77,65,95,52,3,169,243,237,73,240,108,142,27,166,4,165,102,73,134,0,154,28,153,207,102,169,190,248,69,103,201,82,130,52,61,50,7,88,133,69,78,170,52,250,245,26,34,213,206,147,70,216,252,151,4,20,215,103,108,219,229,77,110,133,243,202,80,33,0,0,0,7,84,65,66,76,69,95,49,2,195,151,7,60,138,188,230,212,20,12,155,150,18,9,221,120,59,255,26,28,252,153,155,178,152,89,207,177,108,70,252,43,123,186,45,30,255,252,224,208,51,245,150,180,208,48,117,5,153,190,103,13,181,147,175,134,225,146,63,232,161,187,24,0,0,0,7,84,65,66,76,69,95,50,44,113,197,139,102,73,143,144,59,59,187,218,61,5,206,143,251,87,26,75,60,248,53,51,243,247,27,153,160,79,110,107,3,157,206,55,249,77,27,189,151,204,234,50,162,36,254,42,250,239,188,189,8,12,132,220,234,144,181,79,78,10,133,143,0,0,0,7,84,65,66,76,69,95,51,39,220,68,151,126,254,107,55,70,162,144,112,111,79,114,117,120,60,115,207,229,104,71,216,72,253,147,182,59,243,32,131,10,83,102,38,109,215,183,26,16,179,86,3,2,38,162,222,12,191,46,220,143,8,91,22,215,54,82,177,94,206,216,245,0,0,0,7,84,65,66,76,69,95,52,19,96,151,215,158,27,10,227,115,37,94,135,96,196,153,0,167,88,142,196,214,128,156,144,187,69,16,5,163,222,48,119,19,221,117,21,204,172,64,149,48,45,32,79,6,240,191,242,89,93,119,189,247,46,74,205,176,176,180,57,105,134,13,152,0,0,0,10,84,65,66,76,69,95,84,89,80,69,22,255,53,1,54,145,33,212,16,180,69,146,146,57,186,5,127,226,17,218,209,183,6,228,154,59,85,146,15,172,32,236,30,25,9,135,235,217,207,72,15,96,139,130,19,74,0,235,128,7,103,60,30,209,11,131,74,105,90,223,0,104,82,42,0,0,0,0,0]} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/brillig_integer_binary_operations.json b/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/brillig_integer_binary_operations.json new file mode 100644 index 00000000000..e9ea0637f20 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/brillig_integer_binary_operations.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/main.json b/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/main.json deleted file mode 100644 index f7b5b675d9f..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_integer_binary_operations/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1c7VLaQBS9GD4tUqVK/ai6flSt/ZOQAOFfp29SWnz/R6hrNuUujZ3O5GxmTe6dcXKH4GHP2SznEEK+EtF3yip4/tuh1+ub2Yblau4Qe9pimLwfmu3A8OT7BwW8u/ixhV32mijMzjNGj/HIK+czMq/ZZvsU2x+w/+2Yvs0ey3XoFGiV7+uRrTWSYEQFpHLsOJwnyXoxXUdx9COcLlfpLExmq3kapdEsnf2apnG8TpN0sVwtF+EySuJ19DRbxk8GvAXE2sFxToMiQQl+8ETAMYd8vAHr21tzx/c7WBDW8VKk44gcH6wuJilwgNsm3MHvincbP0chg/Ra07q5cYf14sYbzorEjf+Ih8Lq4jgnVbkxcMyWG/dYL25cErNL9gpD4fbJbzfWvPv4OXLqxkhN6+bG3J3EjTePKxI3fqkBEGsXx/lnVW4MHLPlxu9YL25cEnPXCIrGHZLfbqx5D/Fz5NSNkZrWzY33WJ+/QTTdjfVW0f+7cf68fN+bdd49INYIxzmuynmBY7ac9z3rxXlLYo6MoGjcffLbeTXvffwcOXVepKYB2V/vODpmnTqvQ+yYL+ID1ucOr51q+82njk7fZzxoi2/+Zpc7teau6G+nb5H9GVtRsfP3tvTh2vXYtpI0gF68B/TmYnPkENuKzWPWS2zOKl8oXsbmqiLkGIdlRcgPrJcIWRJzbARF4x6S3xFS8z7Ez5HTCInUtAYuFPGFdsR6caGsvHYhjoleKEckZzlZWXFtwnpZKBteihoe1yY4LCuufWS9xLWSmBMjKBr3mPyOa5r3MX6OnMY1pKYVuZDLs3JzvtBOWC8utOGlqIFx7YQkrrGy4top62WhZKVPaytq4JfSp0CsMxznaVURFThmK6J+Yr1E1JKYZ0ZQNO45+R1RNe9z/Bw5jahITevmvBesF+fdPEdRA533Aoh1ieM8r8p5gWO2nFexXpy3JOalERSNe0V+O6/mfYWfI6fOi9RULgf7ZyV8EV+zXi4He/1yMP3jBkVyOVgh9jVJbGZlxeYb1ktszkr/6kZRA2PzDRDrFsi5qtgMHLMVmz+zXmJzScxbIyga9478js2a9x1+jpzGZqSmdXPee9bL3QSy0glEkdxN4KXugVgPMM5RZXfaw43ZduMvrBc3Lon5YARF4z6S326seT/i58ipG6M1Larfpoao7xxXAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_keccak/target/brillig_keccak.json b/crates/nargo_cli/tests/test_data/brillig_keccak/target/brillig_keccak.json new file mode 100644 index 00000000000..2479c628955 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_keccak/target/brillig_keccak.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_keccak/target/main.json b/crates/nargo_cli/tests/test_data/brillig_keccak/target/main.json deleted file mode 100644 index fae667945ae..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_keccak/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_keccak/target/witness.tr b/crates/nargo_cli/tests/test_data/brillig_keccak/target/witness.tr index 7373c9eda25..e681896f1c8 100644 Binary files a/crates/nargo_cli/tests/test_data/brillig_keccak/target/witness.tr and b/crates/nargo_cli/tests/test_data/brillig_keccak/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/brillig_loop/target/main.json b/crates/nargo_cli/tests/test_data/brillig_loop/target/brillig_loop.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_loop/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_loop/target/brillig_loop.json diff --git a/crates/nargo_cli/tests/test_data/brillig_modulo/target/main.json b/crates/nargo_cli/tests/test_data/brillig_modulo/target/brillig_modulo.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_modulo/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_modulo/target/brillig_modulo.json diff --git a/crates/nargo_cli/tests/test_data/brillig_nested_arrays/target/main.json b/crates/nargo_cli/tests/test_data/brillig_nested_arrays/target/brillig_nested_arrays.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_nested_arrays/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_nested_arrays/target/brillig_nested_arrays.json diff --git a/crates/nargo_cli/tests/test_data/brillig_not/target/brillig_not.json b/crates/nargo_cli/tests/test_data/brillig_not/target/brillig_not.json new file mode 100644 index 00000000000..c0bd0fbc615 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_not/target/brillig_not.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1XWW6DMBAdzBaW0p8exMYQzF+vUlS4/wWqVjRjdaBupYgxChIjIVsOeX6ezbxnAHiBm4X4rC3A8RVHuc1UwIclHXS5sGuP2EoQTOvziKxlOAp8ZktIPOh/PuF3rAIyF/hO+M87wR84mYNnRbgAn09kAuy5JiuCyU34O5EFOuYDNxIYlPWmoYe9LZaW16YZu3pUWr3Juh9MK5t2uBplVGva99poPZrGdP3Qd7JXjR7V1PZ6nG4WMmBNSCziO6MMXcHjTxLFyZnyjcm8wDGDn4K2dpRiiglX2hjseWxjiJjjQxuebVrRau+MrIUOX9vfUvDYEMDhFIu9tbBiRqwEjleknJwp35TM10k1m00mDwW1yBeXH73eXr6ClHrAvQBf8vs694U/RovP20f26V7SQYAf3zLHbTfpYG/h3LF2Sodttot0mJ1EpUMO/qUDLaKt0iEDviaSw/G+Sjg5U76FY35Kh7vtlA6zFYxYJeOZ9ypSRs6LIn0i81M6bMQs0aHcuBU8tnQoMVjMMfIqHTh9KgjH9e022xc2nM0FohgAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_not/target/main.json b/crates/nargo_cli/tests/test_data/brillig_not/target/main.json deleted file mode 100644 index 76c5ee452e2..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_not/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1WW26DMBBc3iFQ+tOD2BiC+ctVigr3v0ClxoqtLsj9qBhHicRKEasgzY5nd/G8E9EH3SO+/SL6DZdf7VPsCxnhsARtAoTbJjeMdKMDXAQjtCn0bQvFfxRNAjZAiUvXzUM7SyU/RTtOuhddP1201LLX/VerlZp1p4dxGgcxyk7NculHNS/3SABYiyWW4s4oEl/zCD/MSM6cb8byyj5LOyM8cpZfQTxyvE4iY1xLxtmdp7HvU3B/zDkS1vuI1YgZH/df4tHavSso4AeBPKI47L2LlQGxcnq9JUVy5nwLlm+HyoQbpgALtZoXn44NBR7WEE0qAuCeCDf8oc59wvdoZY2eWdPQdjMOpCmQY2tumzM9wG6aQtxu+oqi7WYMGBZnN0vg4J3p9W4yJGfOt/Lkh938dxx200QFxKqBZ37UkgI5r5b0jeWH3dyJWVtB0bgNPbfdrG2zwD0KajeRmsaM4/Z2M/EDo2jqqAoVAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_oracle/target/main.json b/crates/nargo_cli/tests/test_data/brillig_oracle/target/brillig_oracle.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_oracle/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_oracle/target/brillig_oracle.json diff --git a/crates/nargo_cli/tests/test_data/brillig_pedersen/target/main.json b/crates/nargo_cli/tests/test_data/brillig_pedersen/target/brillig_pedersen.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_pedersen/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_pedersen/target/brillig_pedersen.json diff --git a/crates/nargo_cli/tests/test_data/brillig_recursion/target/main.json b/crates/nargo_cli/tests/test_data/brillig_recursion/target/brillig_recursion.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_recursion/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_recursion/target/brillig_recursion.json diff --git a/crates/nargo_cli/tests/test_data/brillig_references/target/brillig_references.json b/crates/nargo_cli/tests/test_data/brillig_references/target/brillig_references.json new file mode 100644 index 00000000000..167e6a20c57 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_references/target/brillig_references.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2cS3PTMBSF5dpOIitp0/QVHi2lD6DvNG2HbfiBLNnBmr/Az6MyusOJqqbTQbc5C+4ME8nC93z3SHacOPWKMaYwf6KENoZsm4XXyb/FdZEv1yRm/RVg7f2/lWisA+1ZJv1Ofn8m9X2OOuRaDdxVXo2pDfOdmufYIwP6FthK8LWTl69dI3XEUoOeDwcMK4os7hFtk9CuFXwwkQ8SdYKlJGKpiFiKJbNY8/D4Sh1LeN6q4fVH8XAfrEnz+JPzdXwMNMBQE7BURCwlEUu8nhoYx/NFLy/fjc/RDbkq0OyBtozLG/kg/L8mL0v7fmfNfCw6bhvwxeVlmXiOfshlQWeQV6ddH/2ovj74bEJtFtpaLC6h3SR8eOx9VcMbE3ljEt5IlEQsFRFLTcTSIWLpErH0iFi0z3fPYWmIWDTPvc9l6ROxFEtmeey6fRB5hdftMubPjT+Lh/tgTasKNaHODPqihdftAwKWPhGLI2JpiFgsEUuPiKVLxNIhYqmJWCoilpKIJX6/amAcr9Nyf/71OdZCrgo0RaeE8a/A6FnW87K03wsMzXwsui5YV/TFs4xCriHobOTVadfHKKpP+hswF0Noa7G4hLaCztRGNftYNM+i7/fbDO0R8G1l9qEAHckr/S2Yh9T6yM3iEtoKOlMb1exj0ZyIvt9vO7Q3gW8nsw8F6Ehe6YsWejVSZHEJ7SbhQwPj28Aogd+pjRX8MpFfEuMES0nEUhGx1EQsHSKWLhFLj4jFErE0RCyOiKVPxDIgYlklYlkjYhkSsawTsYyIWDaIWDaJWLaIWLaJWHaIWIolszx2X2UceYX3VWQs/j3UOFHTK4WaUGcGfdHC+ypjApYdIpZtIpYtIpZNIpYNIpYREcs6EcuQiGWNiGWViGVAxNInYnFELA0RiyVi6RGxdIlYOkQsNRFLRcRSErHEn1kaGMd7Na8T+74J7ddQx27mOnyOtyFXBZqiU8L4l/ChRu7Bv8vL0t4H3DPzUUT9GbTfgS/vFVj2n8HyHlgO8rJMtOb9EPj3w6uwOxjfhdoOM3MUoCl5pX+opzv1OY6eqP8owXH0gvWLloVte0tmccCwr8cydQltDR0b1exj0XGOc3Ic2gfA9yEvXzsnxxGL9EULvdpTZHEJbQWdqY1q9rFoTpBF47dYH0OuY9D5lNnbAnQkr/RFC/13iiwuoa2gM7VRzT4WzbPo+/1OQvsj8J1m9qEAHckr/VOYB2E4UGRxCe0m4UMD4yfAc56Xp527MzMfi+buHFgu8rJMtP5m9RL4pVZhdzCOvwG5zMvRrsELM++p9C/1dG99jqsn6r9KcFy9YP2iZWHb6ZJZHDCc6bG010exdgPbjmGbjOM5YpLY91rYgFvjN9835m9cg2/CMQ3tG+DQOL4lfwWa+DfpMv4t+tyr8Vnszjz0ZBc8uQ3tO/BE45i/A09E8xI8kfHv4EnXzH/vsgKMuZ+xIWwGmIyZf75GJ8HRzcxRgI7klb5oOWCoFFlcQrsbtv1/XhDX84IUjonPuObR22Wt+dQzT15qzcdrMWvxJiVwH78BOCjDTz1NAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_references/target/main.json b/crates/nargo_cli/tests/test_data/brillig_references/target/main.json deleted file mode 100644 index 8729f33b589..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_references/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2cS1PbMBSFZWwnkZVACK/0AaU8+qA8gmGm2/QHdtddu+5f6N8rcnWnJ0KEYapLzqJ3phPJqu/57pHsOHHwmjGmMH+ihDaGbJuH19m/xXWRL9csZv0VYO3dv7VorAfteSb9Xn5/ZvVdjjrkWg/cVV6N1ob5Ts1z7JEBfQtsJfjay8vXrZE6YqlBz4cDhjVFFveAtklo1wo+mMgHiTrBUhKxVEQsxYpZrLl/fKWOJTxv1fD6o7i/D9akefzJ+To+BhpgqAlYKiKWkoglXk8NjOP5YpCX78bn6IdcFWgOQFvG5Y18FP5fk5ele7+zZjGWHbcN+OLyssw8xzDksqAzyqvTrY9hVN8QfDahNgttLRaX0G4SPjz0vqrhjYm8MQlvJEoiloqIpSZi6RGx9IlYBkQs2ue7p7A0RCya596nsgyJWIoVszx03T6KvMLrdhnz58afxf19sKZ1hZpQZw590cLr9hEBy5CIxRGxNEQslohlQMTSJ2LpEbHURCwVEUtJxBK/XzUwjtdpuT//+hwbIVcFmqJTwvhXYPQsm3lZuu8FxmYxll0XbCr64lkmIdcYdLby6nTrYxLVJ/0tmIsxtLVYXEJbQae1Uc0+ls2z6Pv9tkN7Anw7mX0oQEfySn8H5iG1PnKzuIS2gk5ro5p9LJsT0ff77Yb2NvDtZfahAB3JK33RQq8miiwuod0kfGhgfBcYJfA7tamCXybyS2KaYCmJWCoilpqIpUfE0idiGRCxWCKWhojFEbEMiVhGRCzrRCwbRCxjIpZNIpYJEcsWEcs2EcsOEcsuEcseEUuxYpaH7qtMI6/wvoqMxb+HmiZqeqFQE+rMoS9aeF9lSsCyR8SyS8SyQ8SyTcSyRcQyIWLZJGIZE7FsELGsE7GMiFiGRCyOiKUhYrFELAMilj4RS4+IpSZiqYhYSiKW+DNLA+N4r+ZlYt9Xof0S6tjPXIfP8TrkqkBTdEoY/xI+1Mg9+Dd5Wbr7gAdmMYqoP4f2G/DlrQLL4RNY3gLLUV6Wmda8HwP/YXgVdgfj+1DbcWaOAjQlr/SP9XRbn+PkkfpPEhwnz1i/aFnYdrBiFgcMh3osrUtoa+jYqGYfy45znJPT0D4Cvnd5+bo5OY1YpC9a6NWBIotLaCvotDaq2ceyOUEWjd9ivQ+5TkHnQ2ZvC9CRvNIXLfTfKbK4hLaCTmujmn0sm2fR9/t9DO33wHeW2YcCdCSv9M9gHoThSJHFJbSbhA8NjH8EnvO8PN3cfTKLsWzuzoHlIi/LTOtvVi+BX2oVdgfj+BuQy7wc3Rq8MIueSv9ST/fW57h6pP6rBMfVM9YvWha2na2YxQHDJz2W7voo1m5gG54PZPwCts2ifbV+392avzEDj4TjOrRb4NA4liV/BZr49+cy/i36jKvxuevW3PdkHzy5Ce1b8ETj+L4FT0TzEjyR8e/gSd8sfseyBoy5n6chbAaYjFl8lkYvwdHPzFGAjuSVvmg5YKgUWVxCux+2/X82ENezgRSOic+45tHbVa351PNNnmvNx2sxa/EmJXAXvwG1l/fkKU0AAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_scalar_mul/target/main.json b/crates/nargo_cli/tests/test_data/brillig_scalar_mul/target/brillig_scalar_mul.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_scalar_mul/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_scalar_mul/target/brillig_scalar_mul.json diff --git a/crates/nargo_cli/tests/test_data/brillig_schnorr/target/main.json b/crates/nargo_cli/tests/test_data/brillig_schnorr/target/brillig_schnorr.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_schnorr/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_schnorr/target/brillig_schnorr.json diff --git a/crates/nargo_cli/tests/test_data/brillig_sha256/target/brillig_sha256.json b/crates/nargo_cli/tests/test_data/brillig_sha256/target/brillig_sha256.json new file mode 100644 index 00000000000..4df424fcecf --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_sha256/target/brillig_sha256.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_sha256/target/main.json b/crates/nargo_cli/tests/test_data/brillig_sha256/target/main.json deleted file mode 100644 index 89566631d2e..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_sha256/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_sha256/target/witness.tr b/crates/nargo_cli/tests/test_data/brillig_sha256/target/witness.tr index 94082c71dfc..15a1553cc33 100644 Binary files a/crates/nargo_cli/tests/test_data/brillig_sha256/target/witness.tr and b/crates/nargo_cli/tests/test_data/brillig_sha256/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/brillig_slices/src/main.nr b/crates/nargo_cli/tests/test_data/brillig_slices/src/main.nr index 7e4e8729199..34a9afcd515 100644 --- a/crates/nargo_cli/tests/test_data/brillig_slices/src/main.nr +++ b/crates/nargo_cli/tests/test_data/brillig_slices/src/main.nr @@ -2,71 +2,75 @@ use dep::std::slice; use dep::std; unconstrained fn main(x: Field, y: Field) { - // Mark it as mut so the compiler doesn't simplify the following operations - // But don't reuse the mut slice variable until this is fixed https://github.com/noir-lang/noir/issues/1931 - let slice: [Field] = [y, x]; + let mut slice: [Field] = [y, x]; assert(slice.len() == 2); - let mut pushed_back_slice = slice.push_back(7); - assert(pushed_back_slice.len() == 3); - assert(pushed_back_slice[0] == y); - assert(pushed_back_slice[1] == x); - assert(pushed_back_slice[2] == 7); + slice = slice.push_back(7); + assert(slice.len() == 3); + assert(slice[0] == y); + assert(slice[1] == x); + assert(slice[2] == 7); // Array set on slice target - pushed_back_slice[0] = x; - pushed_back_slice[1] = y; - pushed_back_slice[2] = 1; - - assert(pushed_back_slice[0] == x); - assert(pushed_back_slice[1] == y); - assert(pushed_back_slice[2] == 1); - - assert(slice.len() == 2); - - let pushed_front_slice = pushed_back_slice.push_front(2); - assert(pushed_front_slice.len() == 4); - assert(pushed_front_slice[0] == 2); - assert(pushed_front_slice[1] == x); - assert(pushed_front_slice[2] == y); - assert(pushed_front_slice[3] == 1); - - let (item, popped_front_slice) = pushed_front_slice.pop_front(); + slice[0] = x; + slice[1] = y; + slice[2] = 1; + + assert(slice[0] == x); + assert(slice[1] == y); + assert(slice[2] == 1); + + slice = push_front_to_slice(slice, 2); + assert(slice.len() == 4); + assert(slice[0] == 2); + assert(slice[1] == x); + assert(slice[2] == y); + assert(slice[3] == 1); + + let (item, popped_front_slice) = slice.pop_front(); + slice = popped_front_slice; assert(item == 2); - assert(popped_front_slice.len() == 3); - assert(popped_front_slice[0] == x); - assert(popped_front_slice[1] == y); - assert(popped_front_slice[2] == 1); + assert(slice.len() == 3); + assert(slice[0] == x); + assert(slice[1] == y); + assert(slice[2] == 1); - let (popped_back_slice, another_item) = popped_front_slice.pop_back(); + let (popped_back_slice, another_item) = slice.pop_back(); + slice = popped_back_slice; assert(another_item == 1); - assert(popped_back_slice.len() == 2); - assert(popped_back_slice[0] == x); - assert(popped_back_slice[1] == y); + assert(slice.len() == 2); + assert(slice[0] == x); + assert(slice[1] == y); - let inserted_slice = popped_back_slice.insert(1, 2); - assert(inserted_slice.len() == 3); - assert(inserted_slice[0] == x); - assert(inserted_slice[1] == 2); - assert(inserted_slice[2] == y); + slice = slice.insert(1, 2); + assert(slice.len() == 3); + assert(slice[0] == x); + assert(slice[1] == 2); + assert(slice[2] == y); - let (removed_slice, should_be_2) = inserted_slice.remove(1); + let (removed_slice, should_be_2) = slice.remove(1); + slice = removed_slice; assert(should_be_2 == 2); - assert(removed_slice.len() == 2); - assert(removed_slice[0] == x); - assert(removed_slice[1] == y); + assert(slice.len() == 2); + assert(slice[0] == x); + assert(slice[1] == y); - let (slice_with_only_x, should_be_y) = removed_slice.remove(1); + let (slice_with_only_x, should_be_y) = slice.remove(1); + slice = slice_with_only_x; assert(should_be_y == y); - assert(slice_with_only_x.len() == 1); - assert(removed_slice[0] == x); + assert(slice.len() == 1); + assert(slice[0] == x); - let (empty_slice, should_be_x) = slice_with_only_x.remove(0); + let (empty_slice, should_be_x) = slice.remove(0); assert(should_be_x == x); assert(empty_slice.len() == 0); } +// Tests slice passing to/from functions +unconstrained fn push_front_to_slice(slice: [T], item: T) -> [T] { + slice.push_front(item) +} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_slices/target/brillig_slices.json b/crates/nargo_cli/tests/test_data/brillig_slices/target/brillig_slices.json new file mode 100644 index 00000000000..e14ecc59178 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/brillig_slices/target/brillig_slices.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_slices/target/main.json b/crates/nargo_cli/tests/test_data/brillig_slices/target/main.json deleted file mode 100644 index 977dbeb44f3..00000000000 --- a/crates/nargo_cli/tests/test_data/brillig_slices/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/brillig_to_be_bytes/target/main.json b/crates/nargo_cli/tests/test_data/brillig_to_be_bytes/target/brillig_to_be_bytes.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_to_be_bytes/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_to_be_bytes/target/brillig_to_be_bytes.json diff --git a/crates/nargo_cli/tests/test_data/brillig_to_bits/target/main.json b/crates/nargo_cli/tests/test_data/brillig_to_bits/target/brillig_to_bits.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_to_bits/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_to_bits/target/brillig_to_bits.json diff --git a/crates/nargo_cli/tests/test_data/brillig_to_bytes_integration/target/main.json b/crates/nargo_cli/tests/test_data/brillig_to_bytes_integration/target/brillig_to_bytes_integration.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_to_bytes_integration/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_to_bytes_integration/target/brillig_to_bytes_integration.json diff --git a/crates/nargo_cli/tests/test_data/brillig_to_le_bytes/target/main.json b/crates/nargo_cli/tests/test_data/brillig_to_le_bytes/target/brillig_to_le_bytes.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_to_le_bytes/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_to_le_bytes/target/brillig_to_le_bytes.json diff --git a/crates/nargo_cli/tests/test_data/brillig_top_level/target/main.json b/crates/nargo_cli/tests/test_data/brillig_top_level/target/brillig_top_level.json similarity index 100% rename from crates/nargo_cli/tests/test_data/brillig_top_level/target/main.json rename to crates/nargo_cli/tests/test_data/brillig_top_level/target/brillig_top_level.json diff --git a/crates/nargo_cli/tests/test_data/cast_bool/target/main.json b/crates/nargo_cli/tests/test_data/cast_bool/target/cast_bool.json similarity index 100% rename from crates/nargo_cli/tests/test_data/cast_bool/target/main.json rename to crates/nargo_cli/tests/test_data/cast_bool/target/cast_bool.json diff --git a/crates/nargo_cli/tests/test_data/closures_mut_ref/Nargo.toml b/crates/nargo_cli/tests/test_data/closures_mut_ref/Nargo.toml new file mode 100644 index 00000000000..c829bb160b1 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/closures_mut_ref/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "closures_mut_ref" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/closures_mut_ref/Prover.toml b/crates/nargo_cli/tests/test_data/closures_mut_ref/Prover.toml new file mode 100644 index 00000000000..11497a473bc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/closures_mut_ref/Prover.toml @@ -0,0 +1 @@ +x = "0" diff --git a/crates/nargo_cli/tests/test_data/closures_mut_ref/src/main.nr b/crates/nargo_cli/tests/test_data/closures_mut_ref/src/main.nr new file mode 100644 index 00000000000..ae990e004fd --- /dev/null +++ b/crates/nargo_cli/tests/test_data/closures_mut_ref/src/main.nr @@ -0,0 +1,20 @@ +use dep::std; + +fn main(mut x: Field) { + let one = 1; + let add1 = |z| { + *z = *z + one; + }; + + let two = 2; + let add2 = |z| { + *z = *z + two; + }; + + add1(&mut x); + assert(x == 1); + + add2(&mut x); + assert(x == 3); + +} diff --git a/crates/nargo_cli/tests/test_data/closures_mut_ref/target/closures_mut_ref.json b/crates/nargo_cli/tests/test_data/closures_mut_ref/target/closures_mut_ref.json new file mode 100644 index 00000000000..e87feaacf2c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/closures_mut_ref/target/closures_mut_ref.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1USwoCMQxNpzODK8+S9DNNd17FYuf+R1CwQqldaQoj+CAkZPGSvMBbAeAET+hHKHjHq3cpGb8DKTkurPedqnru9HTJ64CboJnT6nju9ESHj3jSNIBXV1wWN+dyMJksXdHExB6dTxsTk2d/M2xtZschphgwkrOZdh/tXshG3a3lf4QV5aE1/XUTmDv13wQ+5FRFRGneBY5vAov8j4aagKSmqtmxxh26pZbrMggAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/closures_mut_ref/target/witness.tr b/crates/nargo_cli/tests/test_data/closures_mut_ref/target/witness.tr new file mode 100644 index 00000000000..036fce8ef5e Binary files /dev/null and b/crates/nargo_cli/tests/test_data/closures_mut_ref/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/comptime_array_access/target/main.json b/crates/nargo_cli/tests/test_data/comptime_array_access/target/comptime_array_access.json similarity index 100% rename from crates/nargo_cli/tests/test_data/comptime_array_access/target/main.json rename to crates/nargo_cli/tests/test_data/comptime_array_access/target/comptime_array_access.json diff --git a/crates/nargo_cli/tests/test_data/comptime_recursion_regression/target/main.json b/crates/nargo_cli/tests/test_data/comptime_recursion_regression/target/comptime_recursion_regression.json similarity index 100% rename from crates/nargo_cli/tests/test_data/comptime_recursion_regression/target/main.json rename to crates/nargo_cli/tests/test_data/comptime_recursion_regression/target/comptime_recursion_regression.json diff --git a/crates/nargo_cli/tests/test_data/config.toml b/crates/nargo_cli/tests/test_data/config.toml index 88776ed03d2..6fe6c7897e1 100644 --- a/crates/nargo_cli/tests/test_data/config.toml +++ b/crates/nargo_cli/tests/test_data/config.toml @@ -2,4 +2,4 @@ exclude = [] # List of tests (as their directory name) expecting to fail: if the test pass, we report an error. -fail = ["brillig_assert_fail", "dep_impl_primitive"] +fail = ["brillig_assert_fail", "dep_impl_primitive", "workspace_fail", "workspace_missing_toml"] diff --git a/crates/nargo_cli/tests/test_data/constant_return/target/main.json b/crates/nargo_cli/tests/test_data/constant_return/target/constant_return.json similarity index 100% rename from crates/nargo_cli/tests/test_data/constant_return/target/main.json rename to crates/nargo_cli/tests/test_data/constant_return/target/constant_return.json diff --git a/crates/nargo_cli/tests/test_data/contracts/target/main.json b/crates/nargo_cli/tests/test_data/contracts/target/contracts.json similarity index 100% rename from crates/nargo_cli/tests/test_data/contracts/target/main.json rename to crates/nargo_cli/tests/test_data/contracts/target/contracts.json diff --git a/crates/nargo_cli/tests/test_data/debug_logs/src/main.nr b/crates/nargo_cli/tests/test_data/debug_logs/src/main.nr index 29386feb98c..c8d37a938c7 100644 --- a/crates/nargo_cli/tests/test_data/debug_logs/src/main.nr +++ b/crates/nargo_cli/tests/test_data/debug_logs/src/main.nr @@ -1,14 +1,56 @@ use dep::std; fn main(x : Field, y : pub Field) { + let string = "i: {i}, j: {j}"; + std::println(string); + + // A `fmtstr` lets you easily perform string interpolation. + let fmt_str: fmtstr<14, (Field, Field)> = f"i: {x}, j: {y}"; + let fmt_str = string_identity(fmt_str); + std::println(fmt_str); + + let fmt_str_no_type = f"i: {x}, j: {y}"; + std::println(fmt_str_no_type); + + let fmt_str_generic = string_with_generics(fmt_str_no_type); + std::println(fmt_str_generic); + + let s = myStruct { y: x, x: y }; + std::println(s); + + std::println(f"randomstring{x}{x}"); + + let fmt_str = string_with_partial_generics(f"i: {x}, s: {s}"); + std::println(fmt_str); - std::println("*** println ***"); std::println(x); std::println([x, y]); - let s = myStruct { y: x, x: y }; let foo = fooStruct { my_struct: s, foo: 15 }; - std::println(foo); + std::println(f"s: {s}, foo: {foo}"); + + std::println(f"x: 0, y: 1"); + + let s_2 = myStruct { x: 20, y: 30 }; + std::println(f"s1: {s}, s2: {s_2}"); + + let bar = fooStruct { my_struct: s_2, foo: 20 }; + std::println(f"foo1: {foo}, foo2: {bar}"); + + let struct_string = if x != 5 { f"{foo}" } else { f"{bar}" }; + std::println(struct_string); +} + +fn string_identity(string: fmtstr<14, (Field, Field)>) -> fmtstr<14, (Field, Field)> { + string +} + +fn string_with_generics(string: fmtstr) -> fmtstr { + string +} + +fn string_with_partial_generics(string: fmtstr) -> fmtstr { + string } struct myStruct { diff --git a/crates/nargo_cli/tests/test_data/debug_logs/target/debug_logs.json b/crates/nargo_cli/tests/test_data/debug_logs/target/debug_logs.json new file mode 100644 index 00000000000..70e33f07499 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/debug_logs/target/debug_logs.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/debug_logs/target/main.json b/crates/nargo_cli/tests/test_data/debug_logs/target/main.json deleted file mode 100644 index 3f38a77685a..00000000000 --- a/crates/nargo_cli/tests/test_data/debug_logs/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/debug_logs/target/witness.tr b/crates/nargo_cli/tests/test_data/debug_logs/target/witness.tr index 3530c6f59c1..434b9fac277 100644 Binary files a/crates/nargo_cli/tests/test_data/debug_logs/target/witness.tr and b/crates/nargo_cli/tests/test_data/debug_logs/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/diamond_deps_0/target/main.json b/crates/nargo_cli/tests/test_data/diamond_deps_0/target/diamond_deps_0.json similarity index 100% rename from crates/nargo_cli/tests/test_data/diamond_deps_0/target/main.json rename to crates/nargo_cli/tests/test_data/diamond_deps_0/target/diamond_deps_0.json diff --git a/crates/nargo_cli/tests/test_data/distinct_keyword/target/main.json b/crates/nargo_cli/tests/test_data/distinct_keyword/target/distinct_keyword.json similarity index 100% rename from crates/nargo_cli/tests/test_data/distinct_keyword/target/main.json rename to crates/nargo_cli/tests/test_data/distinct_keyword/target/distinct_keyword.json diff --git a/crates/nargo_cli/tests/test_data/ec_baby_jubjub/target/main.json b/crates/nargo_cli/tests/test_data/ec_baby_jubjub/target/ec_baby_jubjub.json similarity index 100% rename from crates/nargo_cli/tests/test_data/ec_baby_jubjub/target/main.json rename to crates/nargo_cli/tests/test_data/ec_baby_jubjub/target/ec_baby_jubjub.json diff --git a/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/ecdsa_secp256k1.json b/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/ecdsa_secp256k1.json new file mode 100644 index 00000000000..6b829c73e42 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/ecdsa_secp256k1.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"array","length":38,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"hashed_message","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_x","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_y","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"signature","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"hashed_message":[39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70],"message":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"pub_key_x":[71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102],"pub_key_y":[103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134],"signature":[135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/main.json b/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/main.json deleted file mode 100644 index ace2a68331d..00000000000 --- a/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"array","length":38,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"hashed_message","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_x","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_y","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"signature","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"hashed_message":[39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70],"message":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"pub_key_x":[71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102],"pub_key_y":[103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134],"signature":[135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/witness.tr b/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/witness.tr index e05a88a992a..4f7d415e499 100644 Binary files a/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/witness.tr and b/crates/nargo_cli/tests/test_data/ecdsa_secp256k1/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/ecdsa_secp256r1/target/main.json b/crates/nargo_cli/tests/test_data/ecdsa_secp256r1/target/ecdsa_secp256r1.json similarity index 100% rename from crates/nargo_cli/tests/test_data/ecdsa_secp256r1/target/main.json rename to crates/nargo_cli/tests/test_data/ecdsa_secp256r1/target/ecdsa_secp256r1.json diff --git a/crates/nargo_cli/tests/test_data/generics/target/main.json b/crates/nargo_cli/tests/test_data/generics/target/generics.json similarity index 100% rename from crates/nargo_cli/tests/test_data/generics/target/main.json rename to crates/nargo_cli/tests/test_data/generics/target/generics.json diff --git a/crates/nargo_cli/tests/test_data/global_consts/src/main.nr b/crates/nargo_cli/tests/test_data/global_consts/src/main.nr index 9bcca2b8071..2ed6e4593dd 100644 --- a/crates/nargo_cli/tests/test_data/global_consts/src/main.nr +++ b/crates/nargo_cli/tests/test_data/global_consts/src/main.nr @@ -12,12 +12,19 @@ struct Dummy { y: [Field; foo::MAGIC_NUMBER] } +struct Test { + v: Field, +} +global VALS: [Test; 1] = [Test { v: 100 }]; +global NESTED = [VALS, VALS]; + fn main(a: [Field; M + N - N], b: [Field; 30 + N / 2], c : pub [Field; foo::MAGIC_NUMBER], d: [Field; foo::bar::N]) { let test_struct = Dummy { x: d, y: c }; for i in 0..foo::MAGIC_NUMBER { assert(c[i] == foo::MAGIC_NUMBER); assert(test_struct.y[i] == foo::MAGIC_NUMBER); + assert(test_struct.y[i] != NESTED[1][0].v); } assert(N != M); diff --git a/crates/nargo_cli/tests/test_data/global_consts/target/global_consts.json b/crates/nargo_cli/tests/test_data/global_consts/target/global_consts.json new file mode 100644 index 00000000000..f57a6ebd850 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/global_consts/target/global_consts.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"c","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"public"},{"name":"d","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"b":[33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"c":[65,66,67],"d":[68,69,70,71,72]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/global_consts/target/main.json b/crates/nargo_cli/tests/test_data/global_consts/target/main.json deleted file mode 100644 index 82fa7bb94c7..00000000000 --- a/crates/nargo_cli/tests/test_data/global_consts/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"b","type":{"kind":"array","length":32,"type":{"kind":"field"}},"visibility":"private"},{"name":"c","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"public"},{"name":"d","type":{"kind":"array","length":5,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"a":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"b":[33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"c":[65,66,67],"d":[68,69,70,71,72]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/global_consts/target/witness.tr b/crates/nargo_cli/tests/test_data/global_consts/target/witness.tr index 33200a80fe2..cadba3b7801 100644 Binary files a/crates/nargo_cli/tests/test_data/global_consts/target/witness.tr and b/crates/nargo_cli/tests/test_data/global_consts/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/hash_to_field/target/main.json b/crates/nargo_cli/tests/test_data/hash_to_field/target/hash_to_field.json similarity index 100% rename from crates/nargo_cli/tests/test_data/hash_to_field/target/main.json rename to crates/nargo_cli/tests/test_data/hash_to_field/target/hash_to_field.json diff --git a/crates/nargo_cli/tests/test_data/higher_order_fn_selector/Nargo.toml b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/Nargo.toml new file mode 100644 index 00000000000..3c2277e35a5 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "higher_order_fn_selector" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/higher_order_fn_selector/src/main.nr b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/src/main.nr new file mode 100644 index 00000000000..767cff0c409 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/src/main.nr @@ -0,0 +1,39 @@ +use dep::std; + +fn g(x: &mut Field) -> () { + *x *= 2; +} + +fn h(x: &mut Field) -> () { + *x *= 3; +} + +fn selector(flag: &mut bool) -> fn(&mut Field) -> () { + let my_func = if *flag { + g + } else { + h + }; + + // Flip the flag for the next function call + *flag = !(*flag); + my_func +} + +fn main() { + + let mut flag: bool = true; + + let mut x: Field = 100; + let returned_func = selector(&mut flag); + returned_func(&mut x); + + assert(x == 200); + + let mut y: Field = 100; + let returned_func2 = selector(&mut flag); + returned_func2(&mut y); + + assert(y == 300); + +} diff --git a/crates/nargo_cli/tests/test_data/let_stmt/target/main.json b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/target/higher_order_fn_selector.json similarity index 100% rename from crates/nargo_cli/tests/test_data/let_stmt/target/main.json rename to crates/nargo_cli/tests/test_data/higher_order_fn_selector/target/higher_order_fn_selector.json diff --git a/crates/nargo_cli/tests/test_data/higher_order_fn_selector/target/witness.tr b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/target/witness.tr new file mode 100644 index 00000000000..4e90289d5e1 Binary files /dev/null and b/crates/nargo_cli/tests/test_data/higher_order_fn_selector/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/higher_order_functions/Nargo.toml b/crates/nargo_cli/tests/test_data/higher_order_functions/Nargo.toml new file mode 100644 index 00000000000..cf7526abc7f --- /dev/null +++ b/crates/nargo_cli/tests/test_data/higher_order_functions/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "higher_order_functions" +authors = [""] +compiler_version = "0.1" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/higher_order_functions/Prover.toml b/crates/nargo_cli/tests/test_data/higher_order_functions/Prover.toml new file mode 100644 index 00000000000..e69de29bb2d diff --git a/crates/nargo_cli/tests/test_data/higher_order_functions/src/main.nr b/crates/nargo_cli/tests/test_data/higher_order_functions/src/main.nr new file mode 100644 index 00000000000..fefd23b7dbc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/higher_order_functions/src/main.nr @@ -0,0 +1,87 @@ +use dep::std; + +fn main() -> pub Field { + let f = if 3 * 7 > 200 as u32 { foo } else { bar }; + assert(f()[1] == 2); + // Lambdas: + assert(twice(|x| x * 2, 5) == 20); + assert((|x, y| x + y + 1)(2, 3) == 6); + + // nested lambdas + assert((|a, b| { + a + (|c| c + 2)(b) + })(0, 1) == 3); + + + // Closures: + let a = 42; + let g = || a; + assert(g() == 42); + + // When you copy mutable variables, + // the capture of the copies shouldn't change: + let mut x = 2; + x = x + 1; + let z = x; + + // Add extra mutations to ensure we can mutate x without the + // captured z changing. + x = x + 1; + assert((|y| y + z)(1) == 4); + + // When you capture mutable variables, + // again, the captured variable doesn't change: + let closure_capturing_mutable = (|y| y + x); + assert(closure_capturing_mutable(1) == 5); + x += 1; + assert(closure_capturing_mutable(1) == 5); + + let ret = twice(add1, 3); + + test_array_functions(); + ret +} + +/// Test the array functions in std::array +fn test_array_functions() { + let myarray: [i32; 3] = [1, 2, 3]; + assert(myarray.any(|n| n > 2)); + + let evens: [i32; 3] = [2, 4, 6]; + assert(evens.all(|n| n > 1)); + + assert(evens.fold(0, |a, b| a + b) == 12); + assert(evens.reduce(|a, b| a + b) == 12); + + // TODO: is this a sort_via issue with the new backend, + // or something more general? + // + // currently it fails only with `--experimental-ssa` with + // "not yet implemented: Cast into signed" + // but it worked with the original ssa backend + // (before dropping it) + // + // opened #2121 for it + // https://github.com/noir-lang/noir/issues/2121 + + // let descending = myarray.sort_via(|a, b| a > b); + // assert(descending == [3, 2, 1]); + + assert(evens.map(|n| n / 2) == myarray); +} + +fn foo() -> [u32; 2] { + [1, 3] +} + +fn bar() -> [u32; 2] { + [3, 2] +} + +fn add1(x: Field) -> Field { + x + 1 +} + +fn twice(f: fn(Field) -> Field, x: Field) -> Field { + f(f(x)) +} diff --git a/crates/nargo_cli/tests/test_data/higher_order_functions/target/higher_order_functions.json b/crates/nargo_cli/tests/test_data/higher_order_functions/target/higher_order_functions.json new file mode 100644 index 00000000000..7e9b8feec6e --- /dev/null +++ b/crates/nargo_cli/tests/test_data/higher_order_functions/target/higher_order_functions.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":{"kind":"field"},"return_witnesses":[83]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/higher_order_functions/target/witness.tr b/crates/nargo_cli/tests/test_data/higher_order_functions/target/witness.tr new file mode 100644 index 00000000000..28701fee014 Binary files /dev/null and b/crates/nargo_cli/tests/test_data/higher_order_functions/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/if_else_chain/target/if_else_chain.json b/crates/nargo_cli/tests/test_data/if_else_chain/target/if_else_chain.json new file mode 100644 index 00000000000..7e8663b8730 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/if_else_chain/target/if_else_chain.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"param_witnesses":{"a":[1],"c":[2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1c7U4UQRBs9gNOkBMERBDkEEEQkJ39uNszmmCiicbfPoAX797/EbR1NpndyK+p3vQlMwnZWQhFV/VM1c384DsR/aB/Y+XPV2SfI+c96rzHnfek857a99TiJvbZ/G7i/KwZsX3e22fmN8yKg1Vk47KcT/K5KczPLJ/O6iorq9m4NrWp6upXXhfFvC7ryXQ2nWRTUxZzs6imxcKCRUCsVRzHLLaad8cKWEtkzW69a87cXSPdNbEqwIk6f6er4/A/34P+cYkmrQngDgi3+KV4D/A96m1zRSSzuR4587C5PDEjKygad510by7mvY7vkUitA1trF9dX1/dg3s2IwXUijXoD2Bekfn2ZMpB/y5QfO/Ngyp6YG1ZQNO4m6TZl5r2J71HLnLRr2gzNx8YYiDWk5TNRZM1uvU+ceTBRT8yhFRSNu0W6TZR5b+F71DKnqIOt6RPeNlDLvgwlJhlDeerMg6F4YsZWUDTuDuk2FOa9g++RSK1sfNuEPyrvCvP2rU+K9wfl/eZ1uSvA+yPJBCf6amQPqCWw1wapX18hDNSyFcLPnHkIYU/MPSsoGnefdIcw897H90j0agStaTM0nz6ek8zmRXNGnmIPSM6wkOsReQWWALEOafnCElmzW+8LZx7C0hPz0AqKxj0i3WHJvI/wPRKplQPjgPAnmGNaPlNJSMZUXjrzYCqemIkVFI17QrpNhXmf4HskUiub3zHhTWUkzNu3Pine98r7zetyJMD7E5h3M9DXYKdALYG9Nkj9+gphoJatEH7lzEMIe2KeWkHRuGekO4SZ9xm+R6LXYNo1lTqBvBbqD/oqDHmaPSc500L2HHkVlgKxLmj5AhNZs1vvG2ceAtMT88IKisa9JN3mzrwv8T0SqZUD45zwQXRFy2cqKcmYyltnHkzFEzO1gqJxr0m3qTDva3yPRGpl87sivKncCPP2rU+K92fl/eZ1eSPA+wuYdzPQV2G3QC2BvTZI/foKYaCWrRB+58xDCHti3lpB0bh3pDuEmfcdvkeiV2HaNZU6gWRC/UFfhSFPs4ZkTCsC9zwCcs4BWPPF3zHpK+Rykgm5wpmHkPPEzK2gaNySdBsy8y7xPRKplUEN4cOjEuaNCDcJ3l+V95vXZSXA+xvJfFhAnzTHQC2BvTZI/foKYaCWrRCeOPMQwp6YYysoGrcm3SHMvGt8j0RPmkhNU6dG3jwP/adPHr8B1U0SW3ZUAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/if_else_chain/target/main.json b/crates/nargo_cli/tests/test_data/if_else_chain/target/main.json deleted file mode 100644 index db42e7d5b0d..00000000000 --- a/crates/nargo_cli/tests/test_data/if_else_chain/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"c","type":{"kind":"array","length":4,"type":{"kind":"integer","sign":"unsigned","width":32}},"visibility":"private"}],"param_witnesses":{"a":[1],"c":[2,3,4,5]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1c224TMRCd7qUNLQ1paOmNhJZeSGhpd7O7yQYhVL6AbyAi+f9PAMNsGVvhyccrR/JIlcepejJzxnNsr9J8I6Lv9Ne2fv9EPF6IeWTMY2OeGPOU5ym/ljB+87cJ/05azOMTj5md5VsCq8imZbmcTZZ5kf/IJvNFXWVltZjWeZ1XdfVzUhfFsi7r2Xwxn2XzvCyW+aqaFysGi4BY27gcs5j5NW0LzCUyZhnvjvDlGjHXxLaDnMh4H5PH7prXoG/uokg7DnA7hFv8rvLu4GvUWnNF5Ka5Xgg/NJclZsSEonF3ye/mUnnv4mvkJNYOx2ri2vJag/NuLAbHiRTqPWBdkPy1JcrA/DVRfin8IMqWmHtMKBp3n/wWZZX3Pr5Gmjj5zmljPl8bYyBWlzZPRJExy3hfCT+IqCVmlwlF4/bIbxFVeffwNdLEKTKwfTrhHRBWNJUdcJ16PPZpfZO4qGdMbsTmtfCD2FhixkwoGveQ/BYblfchvkZOYu1zrOhr9GdyI7Loa3QfiHUErAuSv7ZEGZi/JspvhB9E2RLziAlF4x6T36Ks8j7G18jpNRrNaWM+n1RPyE3zonNG3nhOgTk3a/CE1+Mpj2ekm8+PUhIg1jlt3kaKjFnG+1b4YSO1xDxnQtG4A/J7I1V5D/A1el6oZxzzgMchtfdYISE3jfdO+KHxLDETJhSNe0F+N17zuTtwjZzEOqR/nxEkIK9fwHk3hn6sMARiXQLrguSvLVEG5q+J8nvhB1G2xLxkQtG4V+S3KKu8r/A1cvpYAc1pY+grNvIkfA3kzzypXvN4Q7r5fMVOgVi3tHmbCjJmGe8H4YdNxRLzlglF447I701F5T3C1+h5od5wzCMex9TeFTslN433Ufih8SwxUyYUjXtHfjeeyvsOXyMnsY45VvQV+ys478bQV+wxEOseWBckf22JMjB/TZQ/CT+IsiXmPROKxn0gv0VZ5f2Ar5HTKzaa08bQV2zkSfgRyJ95Un3kUSNjDR+ZnWn/nmnLRw7AWq7+2KytjSAnNxvBRPhhI7DEzJlQNG5Bfm8EKu8CXyMnsWYcK/p0/kRuNkD06TwDYpXAuiD5a0uUgflrolwJP4iyJWbJhKJxp+S3KKu8p/gaOT2dIzlNRYyqef73jUfKfgET1iUOfkkAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/if_else_chain/target/witness.tr b/crates/nargo_cli/tests/test_data/if_else_chain/target/witness.tr index 62d88832f6d..ff71010966a 100644 Binary files a/crates/nargo_cli/tests/test_data/if_else_chain/target/witness.tr and b/crates/nargo_cli/tests/test_data/if_else_chain/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/inner_outer_cl/Nargo.toml b/crates/nargo_cli/tests/test_data/inner_outer_cl/Nargo.toml new file mode 100644 index 00000000000..1470053df2f --- /dev/null +++ b/crates/nargo_cli/tests/test_data/inner_outer_cl/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "inner_outer_cl" +authors = [""] +compiler_version = "0.7.1" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/inner_outer_cl/src/main.nr b/crates/nargo_cli/tests/test_data/inner_outer_cl/src/main.nr new file mode 100644 index 00000000000..ce847b56b93 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/inner_outer_cl/src/main.nr @@ -0,0 +1,12 @@ +fn main() { + let z1 = 0; + let z2 = 1; + let cl_outer = |x| { + let cl_inner = |y| { + x + y + z2 + }; + cl_inner(1) + z1 + }; + let result = cl_outer(1); + assert(result == 3); +} diff --git a/crates/nargo_cli/tests/test_data/numeric_generics/target/main.json b/crates/nargo_cli/tests/test_data/inner_outer_cl/target/inner_outer_cl.json similarity index 100% rename from crates/nargo_cli/tests/test_data/numeric_generics/target/main.json rename to crates/nargo_cli/tests/test_data/inner_outer_cl/target/inner_outer_cl.json diff --git a/crates/nargo_cli/tests/test_data/inner_outer_cl/target/witness.tr b/crates/nargo_cli/tests/test_data/inner_outer_cl/target/witness.tr new file mode 100644 index 00000000000..4e90289d5e1 Binary files /dev/null and b/crates/nargo_cli/tests/test_data/inner_outer_cl/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/integer_array_indexing/target/main.json b/crates/nargo_cli/tests/test_data/integer_array_indexing/target/integer_array_indexing.json similarity index 100% rename from crates/nargo_cli/tests/test_data/integer_array_indexing/target/main.json rename to crates/nargo_cli/tests/test_data/integer_array_indexing/target/integer_array_indexing.json diff --git a/crates/nargo_cli/tests/test_data/keccak256/target/keccak256.json b/crates/nargo_cli/tests/test_data/keccak256/target/keccak256.json new file mode 100644 index 00000000000..daac0e499ec --- /dev/null +++ b/crates/nargo_cli/tests/test_data/keccak256/target/keccak256.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/keccak256/target/main.json b/crates/nargo_cli/tests/test_data/keccak256/target/main.json deleted file mode 100644 index e10a86357e2..00000000000 --- a/crates/nargo_cli/tests/test_data/keccak256/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/keccak256/target/witness.tr b/crates/nargo_cli/tests/test_data/keccak256/target/witness.tr index de6cb4f848a..42087edb0f9 100644 Binary files a/crates/nargo_cli/tests/test_data/keccak256/target/witness.tr and b/crates/nargo_cli/tests/test_data/keccak256/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/to_bits/target/main.json b/crates/nargo_cli/tests/test_data/let_stmt/target/let_stmt.json similarity index 100% rename from crates/nargo_cli/tests/test_data/to_bits/target/main.json rename to crates/nargo_cli/tests/test_data/let_stmt/target/let_stmt.json diff --git a/crates/nargo_cli/tests/test_data/main_bool_arg/target/main.json b/crates/nargo_cli/tests/test_data/main_bool_arg/target/main_bool_arg.json similarity index 58% rename from crates/nargo_cli/tests/test_data/main_bool_arg/target/main.json rename to crates/nargo_cli/tests/test_data/main_bool_arg/target/main_bool_arg.json index 8a0195d4154..ed91bcdeb5b 100644 --- a/crates/nargo_cli/tests/test_data/main_bool_arg/target/main.json +++ b/crates/nargo_cli/tests/test_data/main_bool_arg/target/main_bool_arg.json @@ -1 +1 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"boolean"},"visibility":"private"},{"name":"y","type":{"kind":"array","length":2,"type":{"kind":"boolean"}},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/7VVUQ7DIAhFbV2yj51Fqlb821VmZu9/hG2ZS5jxr0hiEEzgwVO8AMAVvqLeSzetmK0727T9ynzAzriopu9Nu3OCisXybg+hpq2ix4fbcqHoQiw7IWGk+NzI+0qBUi45uYzBVzxi9kcLxnEaYZxaEKcRjLXI1egM43cm55KYOd6V7Zem9eBO2Ak1QZen7+Nt4BNNPoOkdUJcC7IPfkbdVp6jv+HUYz7bBwuyQ+CHcfQBfOQFqMaxRWUGAAA=","proving_key":null,"verification_key":null} \ No newline at end of file +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"boolean"},"visibility":"private"},{"name":"y","type":{"kind":"array","length":2,"type":{"kind":"boolean"}},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/7VVUQ7DIAhFbV2yj51Fqrb4t6usmb3/EbZlNKGmf0US88BEeIDiDQDu8BfzXZbRCNs2tmN95HNWoIOjGMYnY7gmaISvGOaU6jJVjPgKU1kph5TXmZAwU35PFGOlREtZyxIKplhxyyVu7EzydMo8rSJPp+hr0MsxONHfnj3X5Cz5jkIfGO3JnfAdcoImTlvHx8meavAeTRo7+PWg++B75O31e3QYTi3nq3XwoDsEdo5nH8BPPgHj5KhlBgAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/main_return/target/main.json b/crates/nargo_cli/tests/test_data/main_return/target/main_return.json similarity index 100% rename from crates/nargo_cli/tests/test_data/main_return/target/main.json rename to crates/nargo_cli/tests/test_data/main_return/target/main_return.json diff --git a/crates/nargo_cli/tests/test_data/merkle_insert/target/main.json b/crates/nargo_cli/tests/test_data/merkle_insert/target/main.json deleted file mode 100644 index ba55f8ff17d..00000000000 --- a/crates/nargo_cli/tests/test_data/merkle_insert/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"old_root","type":{"kind":"field"},"visibility":"private"},{"name":"old_leaf","type":{"kind":"field"},"visibility":"private"},{"name":"old_hash_path","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"private"},{"name":"new_root","type":{"kind":"field"},"visibility":"public"},{"name":"leaf","type":{"kind":"field"},"visibility":"private"},{"name":"index","type":{"kind":"field"},"visibility":"private"},{"name":"mimc_input","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"index":[8],"leaf":[7],"mimc_input":[9,10,11,12],"new_root":[6],"old_hash_path":[3,4,5],"old_leaf":[2],"old_root":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/merkle_insert/target/merkle_insert.json b/crates/nargo_cli/tests/test_data/merkle_insert/target/merkle_insert.json new file mode 100644 index 00000000000..566d6d67556 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/merkle_insert/target/merkle_insert.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"old_root","type":{"kind":"field"},"visibility":"private"},{"name":"old_leaf","type":{"kind":"field"},"visibility":"private"},{"name":"old_hash_path","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"private"},{"name":"new_root","type":{"kind":"field"},"visibility":"public"},{"name":"leaf","type":{"kind":"field"},"visibility":"private"},{"name":"index","type":{"kind":"field"},"visibility":"private"},{"name":"mimc_input","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"index":[8],"leaf":[7],"mimc_input":[9,10,11,12],"new_root":[6],"old_hash_path":[3,4,5],"old_leaf":[2],"old_root":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+29C9h11dQG/Eg6n5AkIUlCMs+H5JQkSZIkSZpHSZIkSZIkSZIk5JRTkiRJCEmShJAkIYQkJCGE/HP0c3378bv+77uWNVxjXms9vPU+vfvdz7jHfY973nPNtfc+dO2lpaPWXLr9607/77+W7rjw7xX/8d/h1x3+8T18rdp+rdZ+rd5+rdF+rfCPX//8usM//v2of/yb/WdffJXxnov9Ex/AXqv9Wvsftd/hH/9e8x+//+f3a/3L92sv4Fv6l549CgGvZEapYkXhkgcmfHSaKR2N445rp7NwUhannPXRW+a5koVX7WX9x5OtOeJzvWP18Xj4/+vf0DpL/X+/1hrvufLaI/KK1b8VRuofhmbWGbF/vWC+88iYx/ZT6N06/+Z5/1Pc7xpZ32PjBp9ZEwH3KcR98Z913mXEXo7INT+FuG5WQNLNezuYlzsj4H5fJ/Ny1xF7OSLXfMz+AbcrLf3PegoecVv7ddd//Bu+1m2/7ra0/Gvs9XetEZ9rvaU+MseYmO++RDtzwN5xraXxveQDxD0UZmc9BNyndeKh64/YyxG55qcR1w3My90RdPMh4rjBI9ZFwH1GJ/NyjxF7OSLX/AzEzAEeAVnjHkv/kzk2aL/uubT8a+z1d+0Rn2vDpT4yx5iY77VEO3PAdeu1l8b3ko8Q91CYnQ0RcJ/ViYfee8Rejsg1P4u4bmBe7oWgm48Rxw0esQEC7nM6mZf7jNjLEbnm5yBmDvAIyBr3WfqfzLFR+3XfpeVfY5/t3WFE3jYa8bk2Hg/j7Wes/3pGurQ0/tyOWfNivfdb+P0/z7xX+DeaWAkB09K//Jx/7eNa/+a/kQ5hG/+joWM/7yZL44kfC/cm43O0bCGg3FMYmBUQa8W4KeT+7dem7dcDlpbfFHL/peU3gWz6L98/YKmvm0LuP+JzfaKTm0I2He+58gNG5PUTndwUMqZmNlsad83qAfMDl2iv0zBv918afxP0KeKbv5Xbc2yGgPu8TjZ/DxqxlyNyzc/r4OaIByLo5rMdzAuGT5zfybw8eMRejsg1Px/xYgl4BFwkefDS/1ws2bz9esjS8q+x199NR3yuLZb6yBxjYn7oEu3MARdXNl0a30s+T9xDYXa2QMB9YSceykbs5Yhc8ws7uCnkoQi6+SJx3OARmyPgvriTeeEj9nJErvnFiJkDGgpZgy/9T+YQ0Mul5V9jr78PGPG51FIfmWNMzHqJduaAQ+4HLI3vJV8m7qEwOwoB96WdeKgZsZcjcs0v7eCmEI2gm68Rxw0eIRBwX9bJvNgRezki1/wyxMwBHgFZwy79T+Zw7ZdfWv419tneSiPy5kZ8ri3Hw/hfuylkzJoX633Ywu/nm0L+w+fc8h8NHft5t1oaT/xYuLcanyPUm0Ko9xTejWTVpfEX6ocv0Q4ogPnhCLgfMVHcjySOG3h5JALuR3XA96MQcD964blEESXGyK0T3kQjs3Mlce8q89aE7F1MPKsSWfaC55zbo51J0RbLgndF94R7a+K4gZetEXA/ZmmaOt+GON/AyzYIuB9LnG8s3NsSxw28bIuA+3HEcWPN93ZLtOcbeNkOAffjF3HzWBPXKurILM9CZGY408ZIraVjvDrtEq9CciZYVEl4Hqzw2QjHs1S+J9zbE8cNvGyPgPsJS7TnG4vvHYjzDbzsgID7icT5xsK9I3HcwMuOCLifRBw31nzvtER7voGXnRBwP3nhubgwqQapRWRFWMaVElGawpKoyTnhbKpZxlpSas8oQk2syGJddiVHFbLrCffOxHEDLzsj4H7KEu35xuJ7F+J8Ay+7IOB+KnG+sXDvShw38LIrAu6nEceNNd+7LdGeb+BlNwTcT1+sUTKfLTM2RKNz4cH7WoSsSrvMYpKVu6R9NEaJUpVrwI31pXKbovHCpZ5w704cN/CyOwLuZyzRnm8svvcgzjfwsgcC7mcS5xsL957EcQMveyLgfhZx3FjzvdcS7fkGXvZCwB0Wnot7lZTxUjHvjfGGxeKc5jLVIoVvsYULXS2X3oV2tFCU8lbW2PAr284UcHILFu5IHDfwEhFwpyXa843FdybON/CSEXAX4nxj4a7EcQMvFQH3s4njxprvvZdozzfwsjcC7ucs1qiDU944FVM7IEgsm+Kr5D6qHIowOXLLrWxXHgxr/zl764rimflgdTDtcT3h3oc4buBlHwTcz12iPd9YfO9LnG/gZV8E3M8jzjcW7v2I4wZe9kPA/XziuLHme/8l2vMNvOyPgPsFC8/FW/gAiC2qqHbQH7OonmXF4V6+IiWLIrTTAxODCg1sCi20xJyql0JLFXHu28PCfQBx3MDLAQi4X7hEe76x+D6QON/Ay4EIuF9EnG8s3AcRxw28HISA+8XEcWPN98FLtOcbeDkYAfdLFmu00iTDUpa+Zm6Uz8q151LVB1OSjw2q8zWKXFiQ2ZYSYlGy/byoDbM19IT7EOK4gZdDEHC/dIn2fGPxfShxvoGXQxFwv4w431i4DyOOG3g5DAH3y4njxprvw5dozzfwcjgC7lcsPJdolw+8bcf9WSSe4ZqDVRLuy6uGKy8ij1m2gwXtVGLWBGuSkkmmzINVVt/+3mrd4D6COG7g5QgE3K9coj3fWHwfSZxv4OVIBNyvIs43Fu6jiOMGXo5CwP1q4rix5vvoJdrzDbwcjYD7NYs1BimtzFzXYHIqQvDqpBAmMdGuPlQXStCpJpODSr4q73jIoTWj5RZWtSk94T6GOG7g5RgE3K9doj3fWHwfS5xv4OVYBNyvI843Fu7jiOMGXo5DwP164rix5vv4JdrzDbwcj4D7DQvPJaJlTLgiYlWFsfYbUXKOLbko3g4QrEzC+ZzaD9RRVqNK61A7XWClNSYZK3rCfQJx3MDLCQi437hEe76x+D6RON/Ay4kIuN9EnG8s3CcRxw28nISA+83EcWPN91uWaM838PIWBNxvXawxClWqMu06Ai8le5mzNEaqdvyfgiolRqt8cqFdnmDaJsd41tIlm5gxcDdAT7hPJo4beDkZAffblmjPNxbfbyfON/DydgTc7yDONxbudxLHDby8EwH3u4jjxprvU5ZozzfwcgoC7ncv1qgzb0f6SVvTfpMcV9EIrrmR0ofCg/A82VylibpmkyqLqsjkUxa6SIaTW7Bwv4c4buDlPQi437tEe76x+H4fcb6Bl/ch4H4/cb6xcJ9KHDfwcioC7g8Qx40136ct0Z5v4OU0BNwfXHguYXmqsTpXvFWqPZM3xRaRjbO6pZTWFlaMYFwx3rojdfE62Ha+ID2LSd/+lgnd4D6dOG7g5XQE3B9aoj3fWHyfQZxv4OUMBNwfJs43Fu4zieMGXs5EwP0R4rix5vusJdrzDbychYD7owvPxb2RzFeeuW2nBIqHyFPxLElvbYNra7Qpl2RdktY5Eb0LLcIYr03iMpeucJ9NHDfwcjYC7o8t0Z5vLL7PIc438HIOAu6PE+cbC/e5xHEDL+ci4P4EcdxY8/3JJdrzDbx8EgH3pxZxC5s456ZdeNCJyWSryU4qbrNLPErHXPWiFG68UEEr5lWs7R9W8OKLqron3OcRxw28nIeA+9NLtOcbi+/PEOcbePkMAu7PEucbC/f5xHEDL+cj4P4ccdxY833BEu35Bl4uQMD9+UXcsVbrmLKlGJtlO+BXNacGsPogYmCtD1I5H1KWRgldeSji9isQwjth+sJ9IXHcwMuFCLi/sER7vrH4vog438DLRQi4v0icbyzcFxPHDbxcjID7S8RxY833JUu05xt4uQQB95cXazTtWD/ZGEMxXNdUufOmiuhytNmL1A4OEi+BJ8elKj5HU7N2zliRtCw+9IT7UuK4gZdLEXB/ZYn2fGPx/VXifAMvX0XA/TXifGPhvow4buDlMgTcXyeOG2u+v7FEe76Bl28g4P7m0uJ1h9xyS4qBW12qNTnWlHw7J9BemBilVz442w4OdHtOoXVLMzYYFX07XmjN0j3hvpw4buDlcgTc31qiPd9YfF9BnG/g5QoE3N8mzjcW7iuJ4wZerkTA/R3iuLHm+6ol2vMNvFyFgPu7C88lYlYpJ29EkTkYkaJs31SblHDBR5Y1d7Hefqueqa6m0lCH1h8fajTt8kRPuK8mjht4uRoB9/eWaM83Ft/fJ8438PJ9BNw/IM43Fu5riOMGXq5BwP1D4rix5vtHS7TnG3j5EQLuHy/iViW34wJla4shRamkUpKeCWWKlO0J2h9k1n6KZJmlzKJqlyZsjZmnEGvRKJ+bioX7WuK4gZdrEXD/ZIn2fGPx/VPifAMvP0XA/TPifGPhvo44buDlOgTcPyeOG2u+r1+iPd/Ay/UIuH+x8Fzt8gEz7a8koQ2PUVtZVKrthN9nGVlkxZeQolLWap6MiNZmeMFcgVe/28x1T7hvII4beLkBAfcvl2jPNxbfvyLON/DyKwTcvybONxbuG4njBl5uRMD9G+K4seb7piXa8w283ISA+7eLuB2D8/vKstLVl9IiSeBSx5qll8IXqZy0xUipjU6Sqxp9yzDR52ila43qCffNxHEDLzcj4P7dEu35xuL798T5Bl5+j4D7D8T5xsJ9C3HcwMstCLj/SBw31nz/aYn2fAMvf0LA/edF3EbU2k72leDStSsPmhtu2kmBM/Bi98hD5sVFLXVISsNb1tQYhUhcVp908KUn3LcSxw283IqA+y9LtOcbi++/EucbePkrAu6/EecbC/dtxHEDL7ch4P47cdxY8w1P+M/nojjff//Hk46N+w4LuJltYSWo9lwmwKeziBScMELWxIrLPrT44k1QNjjGZQk+QV7RLrW/Ei3XvifcKxDHDbysgID7jnegPd9YfK9InG/gZUUE3HcizjcW7pWI4wZeVkLAvfJE53sV4vMNvKyCgHvVRdxB+VBFSyycR6ZjZiIY34BGHkPWUXDLFLMhB8G5EpWZdmTAmc/FucCj6Qn3asRxAy+rIeBenfh8Y/G9BnG+gZc1EHCvSZxvLNxrEccNvKyFgHvtic73OsTnG3hZBwH3nRevO4gkb/94tdDgpvYljW/HBa6q0BAya3nhWtZqrVcyB62TqsmZdthgW4KRoSfcdyGOG3i5CwLuuxKfbyy+1yXON/CyLgLuuxHnGwv3esRxAy/rIeC++0Tne33i8w28rI+A+x7L+Ha5tEMBA5+n1h7TjvxNTUW73C486KJkzSKUmp2J8LEtoZ0stKdt1x3aY3JMrifcGxDHDbxsgID7nsTnG4vvDYnzDbxsiID7XsT5xsJ9b+K4gZd7I+C+z0TneyPi8w28bISA+76LuCGfeNeO9ln2XFupYpXCw5u/M21rLaZlFVadd7Yo7W0sxWYpZcpCBWd0T7g3Jo4beNkYAff9iM83Ft+bEOcbeNkEAff9ifONhXtT4riBl00RcD9govO9GfH5Bl42Q8D9wAXcQnEu4EPOhUk1GSZcDaLW7CvzLPKi4f1rWHA2W86d1O1iROtRVu00Qfl2qNAT7gcRxw28PAgB94OJzzcW35sT5xt42RwB90OI842FewviuIGXLRBwP3Si882IzzfwwhBw80W+szYtp3gnqsxVuiAr9zU6rpJkXFbFfQysRKeYjMIm1i5HWJ1MLTxVZVxPuAVx3MCLQMAtic83Ft+KON/Ai0LArYnzjYXbEMcNvBgE3Hai8+2Izzfw4hBw+wXcvDJeqmPWyOR11TIpqXh7fi+zN1aGUqpoCabyELj3Nhtro9Y2euNFcaEn3FsSxw28bImA+2HE5xuL762I8w28bIWA++HE+cbC/QjiuIGXRyDgfuRE5/tRxOf7dl4QcD96ETfTSYt2QuBaPhS2GBaZNDy1h1kddbA+i5yMEzy7wIV22TNTsmoNsqWdIvSEe2viuIGXrRFwP4b4fGPxvQ1xvoGXbRBwP5Y431i4tyWOG3jZFgH34yY639sRn2/gZTsE3I9f5FvmduSvA0tSpNgAB+a9dD4J7li7tuCkE7ZGxdtJQslOZeesMbkqlYxk1veEe3viuIGX7RFwP4H4fGPxvQNxvoGXHRBwP5E431i4dySOG3jZEQH3kyY63zsRn2/gZScE3E9ezC3CiGKla0cGOZoEMUVlb4UVXinBU/Y61CBUbSf9LHEpZIhOJhmYCalI0RPunYnjBl52RsD9FOLzjcX3LsT5Bl52QcD9VOJ8Y+HelThu4GVXBNxPm+h870Z8voGX3RBwP32R71KMS7JIl7hvZ/vSe5VYVtnGXOD93xvq9i8hQjtV8FxXJ5IOMjIlRMw+9IR7d+K4gZfdEXA/g/h8Y/G9B3G+gZc9EHA/kzjfWLj3JI4beNkTAfezJjrfexGfb+BlLwTcYQG3KHBrfQMpWFLt9CCLykLwxSjuq/XChJiy9kYzp4QXoT06Z+vaqUI7Y/BM9IQ7EscNvEQE3In4fGPxnYnzDbxkBNyFON9YuCtx3MBLRcD97InO997E5xt42RsB93MWrzsA7Cx5FkE63oAWFrxQPCkjhA9C1NyOEYRqz6HaNQdWWj8yqyVqZ7QJtSfc+xDHDbzsg4D7ucTnG4vvfYnzDbzsi4D7ecT5xsK9H3HcwMt+CLifP9H53p/4fAMv+yPgfsEi3zFIXxlvMEM08LlqRnCvhdWiplyUM9ZmW6VoR/22tCsTJaSqvFZJl2pwzg2wcB9AHDfwcgAC7hcSn28svg8kzjfwciAC7hcR5xsL90HEcQMvByHgfvFE5/tg4vMNvByMgPsli9cdfGoXlpluxwZwNaHhjzkxE3mxslbdIkrVMldvqlOmJRuXmLYic15TqM7FnnAfQhw38HIIAu6XEp9vLL4PJc438HIoAu6XEecbC/dhxHEDL4ch4H75ROf7cOLzDbwcjoD7FctyixGMOd/+OgsmGetVTZUnEXnkDbYMlsvkmQ4uBl7bT9TVasZr4UGz6HrCfQRx3MDLEQi4X0l8vrH4PpI438DLkQi4X0WcbyzcRxHHDbwchYD71ROd76OJzzfwcjQC7tcs5paYjPQNZPt7VvJ21SGLZKr0PCvlXZFepGh1ySlmnVRitTVAmNwuRBh4IXxPuI8hjht4OQYB92uJzzcW38cS5xt4ORYB9+uI842F+zjiuIGX4xBwv36i83088fkGXo5HwP2GRdzB+Spdac/IEtytx4Vl7eKDsbn9xxZSuNJM5napwZpYZbItyTCe2/UJGZxSuifcJxDHDbycgID7jcTnG4vvE4nzDbyciID7TcT5xsJ9EnHcwMtJCLjfPNH5fgvx+QZe3oKA+60LuHm7iFBysaWUqArcUi9dA11DMlloFrRiWrc/DJmzYnyUwbQnY9ak4KzDed93LNwnE8cNvJyMgPttxOcbi++3E+cbeHk7Au53EOcbC/c7ieMGXt6JgPtdE53vU4jPN/ByCgLudy/yndoFBHhRXGzQRLBKcq5j0VL4rJV2WXjHBHPtikT1OSTFTbv8IIzm1cciYk+430McN/DyHgTc7yU+31h8v48438DL+xBwv58431i4TyWOG3g5FQH3ByY636cRn2/g5TQE3B9cvO7gJJNFZCdV4RBJimzH/CFaYYIsVufMcsg+1hJ4UFIYy71vDxNK+vaMXeE+nThu4OV0BNwfIj7fWHyfQZxv4OUMBNwfJs43Fu4zieMGXs5EwP2Ric73WcTnG3g5CwH3RxdxR22F4zyFBjxozlm7wGDbc6tUsjSixFKzTZkX7lq4scYXr6RuT1pq0kX3hPts4riBl7MRcH+M+Hxj8X0Ocb6Bl3MQcH+cON9YuM8ljht4ORcB9ycmOt+fJD7fwMsnEXB/avm5gWigtfW+FlGCE8nYxILLzBkZ25FBYqVdYmjn/YX7FmMUE+0b5qKW1UTVE+7ziOMGXs5DwP1p4vONxfdniPMNvHwGAfdnifONhft84riBl/MRcH9uovN9AfH5Bl4uQMD9+UW+FbNFq+hNaM8gk2G+Bmm9jULIZGUWhgVpdMjaRaGd50Ebw4QVzJuYdU+4LySOG3i5EAH3F4jPNxbfFxHnG3i5CAH3F4nzjYX7YuK4gZeLEXB/aaLzfQnx+QZeLkHA/eXF3BJku6igdWQNZW5nBskJIZL3VgkVE1esXWkQJceqogsNs0q+aCdFzCEVz3vCfSlx3MDLpQi4v0J8vrH4/ipxvoGXryLg/hpxvrFwX0YcN/ByGQLur090vr9BfL6Bl28g4P7m4rmBN6Kh1sX4ll+4TbpdVwjKR95Qhuy85qp9y9rPKRZutY86a+2d4hGO/XNPuC8njht4uRwB97eIzzcW31cQ5xt4uQIB97eJ842F+0riuIGXKxFwf2ei830V8fkGXq5CwP3dxdxilZPaMQ5vKqeFjioJ7rRsFyJ064FyoSqjC3wGWy4+c9MeD+9Op2UO1gfbE+6rieMGXq5GwP094vONxff3ifMNvHwfAfcPiPONhfsa4riBl2sQcP9wovP9I+LzDbz8CAH3jxdzS1ahlmyDZa5o357UqWyNEV5UkVo8STo73Z7FcGZV1j5kWTUvXhof2uN7wn0tcdzAy7UIuH9CfL6x+P4pcb6Bl58i4P4Zcb6xcF9HHDfwch0C7p9PdL6vJz7fwMv1CLh/sZhbEiuRtTTSzgOcMUVYnrJogaRyW227KqFqiHC2wJyLXhcrc2rnBdmL1J4+mJ5w30AcN/ByAwLuXxKfbyy+f0Wcb+DlVwi4f02cbyzcNxLHDbzciID7NxOd75uIzzfwchMC7t8u5hZjWUNTVBUy2GydCZm3f0apZRDVRSeE8clG7UK0LFs4LlDctB8jVcZ531gs3DcTxw283IyA+3fE5xuL798T5xt4+T0C7j8Q5xsL9y3EcQMvtyDg/uNE5/tPxOcbePkTAu4/L/KtSgstGUIJi5y7doggOTOhCJ2YUjYkuD0vJ5ONSLXYWpLI1nuZa7tYIURPuG8ljht4uRUB91+IzzcW338lzjfw8lcE3H8jzjcW7tuI4wZebkPA/feJzvfSCrTnG3iBGsfGfYdF3LlKKXUOXNZ2wl+NZl5Xb3Xm2jpnhOKhpFSrdDX7GIMX7YdX543PtjDfE+4ViOMGXlZAwH3HFWjPNxbfKxLnG3hZEQH3nYjzjYV7JeK4gZeVEHCvPNH5XoX4fAMvqyDgXnWFxXP/WqsR0QsnSmI68hpUyys+mBZXSiw+JCPbE8ssImdFqegLq4X70i47lNIT7tWI4wZeVkPAvTrx+cbiew3ifAMvayDgXpM431i41yKOG3hZCwH32hOd73WIzzfwsg4C7jsv8u1KKkK5hiS1/+d2imC8j7od9NvkPWuXGawVPIaofTTaxsilK+25SzHGq9wT7rsQxw283AUB912JzzcW3+sS5xt4WRcB992I842Fez3iuIGX9RBw332i870+8fkGXtZHwH2PxdySeIiO52iYjcGaHKvltf1dLZLTJlbuZDs/8I4nGU3mNUseeYs1zLqqLe8J9wbEcQMvGyDgvifx+cbie0PifAMvGyLgvhdxvrFw35s4buDl3gi47zPR+d6I+HwDLxsh4L7vIt88F1NdOyFo/ytS81hVCiELL2N2prTflGqka5ccuE7RtVMFJQprD4uxfet6wr0xcdzAy8YIuO9HfL6x+N6EON/AyyYIuO9PnG8s3JsSxw28bIqA+wETne/NiM838LIZAu4HLuYWmbOL2poahDOynRAYlY1M1tbsRA2G52C51VI6AW8154ThtsSsVYglKtMT7gcRxw28PAgB94OJzzcW35sT5xt42RwB90OI842FewviuIGXLRBwP3Si882IzzfwwhBw8wXc3Hh4f5qiuY4ileJyu9DgfbvKYLmw0rRHB1u9qFGqJIusWopc2p/KEFLE+dxzLNyCOG7gRSDglsTnG4tvRZxv4EUh4NbE+cbCbYjjBl4MAm470fl2xOcbeHEIuP0i3yVV157BuwJ4gveh9YC5LNrxAa/Bi6IZd+10ITnvs9YqJ55rkDqVyALrCfeWxHEDL1si4H4Y8fnG4nsr4nwDL1sh4H44cb6xcD+COG7g5REIuB850fl+FPH5vp0XBNyPXsSdE8umWBNqDNLanI2XJaukbFDV1wKf1tLCTK46VyNqZqaK6izcK1B4cj3h3po4buBlawTcjyE+31h8b0Ocb+BlGwTcjyXONxbubYnjBl62RcD9uInO93bE5xt42Q4B9+OX4XaZOW25lj4Z16DndugfTDvqF55nKaRX7aqEDS28+GBjESVxlZ2XzMVock+4tyeOG3jZHgH3E4jPNxbfOxDnG3jZAQH3E4nzjYV7R+K4gZcdEXA/aaLzvRPx+QZedkLA/eQF3NxmblmxEo72i4ePPJeqwlu6Z5mEq06XylUUPFmpVfvLwjs4XrDG25ZsVE+4dyaOG3jZGQH3U4jPNxbfuxDnG3jZBQH3U4nzjYV7V+K4gZddEXA/baLzvRvx+QZedkPA/fRFvn3JRrKsWLu6AO8SG6RqT6+5TjxFaVy7BsF0UrlkYXKVzmiRhWdRmNquVdSecO9OHDfwsjsC7mcQn28svvcgzjfwsgcC7mcS5xsL957EcQMveyLgftZE53sv4vMNvOyFgDss4BZRS8e9khnOCmTMTPugrLLRipo4N5V5n5RhrB34O85zjkqxCm9b056bl55wR+K4gZeIgDsRn28svjNxvoGXjIC7EOcbC3cljht4qQi4nz3R+d6b+HwDL3sj4H7OIt88t6RSvLPFG50gqCQmtCje5uhijdYZ43JLMD61g/9kATNr3YpZiyhjT7j3IY4beNkHAfdzic83Ft/7EucbeNkXAffziPONhXs/4riBl/0QcD9/ovO9P/H5Bl72R8D9ggXcPHCXnDeVC5WycoLXWJgLyTjWMEsjEtdSKcN9KpVZ4ayqSloP9+pXIXvCfQBx3MDLAQi4X0h8vrH4PpA438DLgQi4X0ScbyzcBxHHDbwchID7xROd74OJzzfwcjAC7pcs4oZQEiorocDnorYGmNhODmLNCm4C4Em1H2IjfLiLN1zC7fbeClHaY3TDzXrCfQhx3MDLIQi4X0p8vrH4PpQ438DLoQi4X0acbyzchxHHDbwchoD75ROd78OJzzfwcjgC7lcs4s41a2etMCUpJbTRJSpb27UH2U4PmJEqGm1E5tEw7oVXlreuOGNZCIpx1RPuI4jjBl6OQMD9SuLzjcX3kcT5Bl6ORMD9KuJ8Y+E+ijhu4OUoBNyvnuh8H018voGXoxFwv2YRt7LBMxVT5jbIakyJ2cJb0HFhvWYWbrswTDglAlO2Aa+Zc58lL7lKL7rCfQxx3MDLMQi4X0t8vrH4PpY438DLsQi4X0ecbyzcxxHHDbwch4D79ROd7+OJzzfwcjwC7jcs49sIzo0qLjbgyhrenreIEGL2gQdjS0pMVy9MLEnHGFKJVot2jmBK+3umJ9wnEMcNvJyAgPuNxOcbi+8TifMNvJyIgPtNxPnGwn0ScdzAy0kIuN880fl+C/H5Bl7egoD7rQu4hWM1peJ5g8aiUfCB5rKY4KQLMSZebbsOoYpyWkYhMjM2aFN18cypdvbve8J9MnHcwMvJCLjfRny+sfh+O3G+gZe3I+B+B3G+sXC/kzhu4OWdCLjfNdH5PoX4fAMvpyDgfvci7na+n5kM0USruPK6qGxTLA1/MKmyykwowTWowmUus7bVBNYelZxxmcWecL+HOG7g5T0IuN9LfL6x+H4fcb6Bl/ch4H4/cb6xcJ9KHDfwcioC7g9MdL5PIz7fwMtpCLg/uIg7aB9NUZw5LbI3xrSTBM9tyyU8VOmqsi5aw2SJsqgqZAs43kiZnTApF98T7tOJ4wZeTkfA/SHi843F9xnE+QZezkDA/WHifGPhPpM4buDlTATcH5nofJ9FfL6Bl7MQcH90ATcP1jpZg6/VRmlyu9wABwPF6FSTa+BYtCzD+9ZEzUPUVumia+E5SZ195D3hPps4buDlbATcHyM+31h8n0Ocb+DlHATcHyfONxbuc4njBl7ORcD9iYnO9yeJzzfw8kkE3J9azC3OZF5sYdLXcPs3MbtajC+8oU8htwN+L1M7QNDthyinLPc8hiJqlUpF0RPu84jjBl7OQ8D9aeLzjcX3Z4jzDbx8BgH3Z4nzjYX7fOK4gZfzEXB/bqLzfQHx+QZeLkDA/flFvmuATzlvBwWFq+KSlqw90IdQ2wUG53M7/Jc5MWFqLSmydsggs4kNcGo/llnbE+4LieMGXi5EwP0F4vONxfdFxPkGXi5CwP1F4nxj4b6YOG7g5WIE3F+a6HxfQny+gZdLEHB/eRF3aRi0kboG3f42c8Kn9pelSEoaHmuwJddcFYtMc5UYy1kGK6VrP7tyL3vCfSlx3MDLpQi4v0J8vrH4/ipxvoGXryLg/hpxvrFwX0YcN/ByGQLur090vr9BfL6Bl28g4P7m4nUHGVkJlkcXY5YpGgH37xUtdNXJRalTrKUd8jNIMkIquMdPGa1Trpa3ixU94b6cOG7g5XIE3N8iPt9YfF9BnG/g5QoE3N8mzjcW7iuJ4wZerkTA/Z2JzvdVxOcbeLkKAfd3F3GHVLK2IseahTFKG88kq6lKzxlvf11U6xv2WGS7zMCV86rGmmz7MaH1oPaE+2riuIGXqxFwf4/4fGPx/X3ifAMv30fA/QPifGPhvoY4buDlGgTcP5zofP+I+HwDLz9CwP3jRb5lkre/03vmIocqlBC1xMx1UFrwKtvFBu2ZtkmEWnP7ESYZW4NskSalFmN6wn0tcdzAy7UIuH9CfL6x+P4pcb6Bl58i4P4Zcb6xcF9HHDfwch0C7p9PdL6vJz7fwMv1CLh/sYCb22zacUCLKsLDZ6My3+DpdnhgtRTRtTY4uImvmpx9htsADJMxOJOiF7oV0RPuG4jjBl5uQMD9S+LzjcX3r4jzDbz8CgH3r4nzjYX7RuK4gZcbEXD/ZqLzfRPx+QZebkLA/dtFvr1mmsn2FxSXpqhkZVTtikOIjLlYjdDtlD9pHlo3irXV+2SYScG26xVG5q5w30wcN/ByMwLu3xGfbyy+f0+cb+Dl9wi4/0CcbyzctxDHDbzcgoD7jxOd7z8Rn2/g5U8IuP+8mFtYCqwdGQSvY+Le2QZG2nbobwx3QhlZWPKiBC5ErkY5XXlSRQdvjY9SpJ5w30ocN/ByKwLuvxCfbyy+/0qcb+Dlrwi4/0acbyzctxHHDbzchoD77xOd76U70p5v4AVqHBv3HRZwC1+NTF7qUosQqgips46qPafT1jV4UeiWZXyQSmQVWPYtznhXqtU2R8N7wr0CcdzAywoIuO94R9rzjcX3isT5Bl5WRMB9J+J8Y+FeiThu4GUlBNwrT3S+VyE+38DLKgi4V13MLYUL156h1NpwSR65dTH5dtCfWFI88GyFtO3gH84JTM3Ms9KO/I00JrbjBN0T7tWI4wZeVkPAvTrx+cbiew3ifAMvayDgXpM431i41yKOG3hZCwH32hOd73WIzzfwsg4C7m+uPi7f//y648j4Vx3xuVYbsX+X/5f695/Weefx5pqPqBneS//uMpH+je1boLu7IPjWXe/Yh27WnXUzqD7gd10E3dyNeL7Bwr0ecdzAy3oIuO/eiU+sP/vEoPqA3/URdPPtCebiRd38x++/0kmuu8eIczeiZvhi/0QRJUbYhQpvYjsMdq7AuXBl7cQ3ZN82pzyrEtuFZMFzzu3RcDO2LZaFdllZY/Zvg4n0b2zfAt1tgOBb9+xkvdtw1s2g+oDfDRF0cy/i+RAL972J4wZe7o2A+z6d+MRGs08Mqg/43QhBN9/tJNfd9444XLP/7Isv9k/wWBPXKurILM9CZGY408ZIraVjvDrtEofPV2WCRZWE58EKn41wPEvlMfu38UT6N/bcge42Rpi7+3Xi15vMuhlUH/C7CYJu7k8832Dh3pQ4buBlUwTcD+jEJzabfWJQfcDvZgi6+V4nue6BRHWz2D8uTKpBahFZEZZxpUSUprAkbv/4XWdTzTLWklJDKkJNrMhiXXYlRxWyw+zfgybSv7HnDnT3IIS5e3Anfr35rJtB9QG/myPo5iHE8w0W7i2I4wZetkDA/dBOfILNPjGoPuCXIejmB53kOk5UN8v6J5nPlhkbotG58OB9LUJWpV1mMcnKXdI+GqNEqco14RjrS+U2ReOFS5j9ExPp39hzB7oTCHMnO/FrNetmUH3Ar0LQjSaeb7BwG+K4gReDgNt24hNu9olB9QG/DkE3P+wk13miulnsH/cqKeOlYt4b4w2LxTnNZapFCt+2A1zoarn0LrQj/qKUt7LGph9l29k+7vW6LSfSv7HnDnS3JcLcPawTv95q1s2g+oDfrRB083Di+QYL9yOI4wZeHoGA+5Gd+MSjZp8YVN/t/CLo5sed5LpHE9XNsv7p4JQ3TsXUDuoTy6b4KrmPKociTI7ccivblV7D2n/O3rqieGY+WB1Mexxm/7aeSP/GnjvQ3dYIc/eYTvx6m1k3g+oDfrdB0M1jiecbLNzbEscNvGyLgPtxnfjEdrNPDKoP+N0OQTc/6STXPZ6obhb7x1uoB4m0LYDSsn0jqmdZcXgNTpGSRRHaKb6JQYUmlhTaZiDmVL0UWqqI+3rY7SfSv7HnDnS3PcLcPaETv95h1s2g+oDfHRB080Ti+QYL947EcQMvOyLgflInPrHT7BOD6gN+d0LQzc86yXVPJqqbZf2z0iTDUpa+Zm6Uz8o1jKr6YErysUnF+RpFLizIbEsJsSjZ+hC1YbYGzP7tPJH+jT13oLudEebuKZ349S6zbgbVB/zugqCbpxLPN1i4dyWOG3jZFQH30zrxid1mnxhUH/C7G4Juft5Jrns6Ud0s9k+0y7Xe8uCzSDzDNV6rJLyephquvIg8ZtkO+LVTiVkTrElKJpkyD1ZZzQVm/3afSP/GnjvQ3e4Ic/eMTvx6j1k3g+oDfvdA0M0ziecbLNx7EscNvOyJgPtZnfjEXrNPDKoP+N0LQTe/6CTXBaK6Wda/IKWVmesaTE5FCF6dFMIkJtrV3upCCTrVZHJQyVflHQ85NDG1/QCr2hTM/sWJ9G/suQPdRYS5S534dZ51M6g+4Dcj6KYQzzdYuCtx3MBLRcD97E58Yu/ZJwbVB/zujaCbX3aS655DVDeL/RPRMiZcEbGqwlj7jSg5x7YjULwd5FuZhPM5tUboKKtRpSmsnfKz0oSVjEW9XrfPRPo39tyB7vZBmLvnduLX+866GVQf8Lsvgm6eRzzfYOHejzhu4GU/BNzP78Qn9p99YlB9wO/+CLr5dSe57gVEdbOsf1GoUpVp1215KdnLnKUxUonqU1ClxGiVTy60y8FM2+QYz1q6ZBMzBu7WxOzfARPp39hzB7o7AGHuXtiJXx8462ZQfcDvgQi6eRHxfIOF+yDiuIGXgxBwv7gTnzh49olB9QG/ByPo5jed5LqXENXNsv7pzAsLSVvTfpMcV9EIrrmR0ofCg/A82VylibpmkyqLqsjkUxa6SIZ7ve6QifRv7LkD3R2CMHcv7cSvD511M6g+4PdQBN28jHi+wcJ9GHHcwMthCLhf3olPHD77xKD6gN/DEXTz205y3SuI6maxf8LyVGN1rnirVEPoTbFFZOOsbum/yYoVIxhXjDd1SV28Drad80vPYmpH+Jj9O2Ii/Rt77kB3RyDM3Ss78esjZ90Mqg/4PRJBN68inm+wcB9FHDfwchQC7ld34hNHzz4xqD7g92gE3fyuk1z3GqK6+d2y97M2kvnKM7fttF7xEHkqniXprW1ysTXalEuyLknrnIjehbY1MF6bxGUuqLnumIn0b+y5A90dgzB3r+3Er4+ddTOoPuD3WATdvI54vsHCfRxx3MDLcQi4X9+JTxw/+8Sg+oDf4xF084dOct0biOrmD8s+V9gmzrlpF3p1YjLZarKTitvsEo/SMVe9KIUbL1TQinkVa/uHFbz4oirq+xKfMJH+jT13oLsTEObujZ349YmzbgbVB/yeiKCbNxHPN1i4TyKOG3g5CQH3mzvxibfMPjGoPuD3LQi6+WMnue6tRHWz2D8ea7WOKVuKsVm6po2aUxNI9UHEwJqOpHI+pCyNErryUMTtV3yFd8Lg5rqTJ9K/secOdHcywty9rRO/fvusm0H1Ab9vR9DNO4jnGyzc7ySOG3h5JwLud3XiE6fMPjGoPuD3FATd/LmTXPduorpZ1j+TbE42xlAM1zVV7rypIrocbfYitQP8xEvgyXGpis/R1KydM1YkLYsPmP17z0T6N/bcge7egzB37+3Er98362ZQfcDv+xB0837i+QYL96nEcQMvpyLg/kAnPnHa7BOD6gN+T0PQzV86yXUfJKqbvyy7zpvbfiDFwK0u1Zoca0q+nddrL0yM0isfnG0H+LphFVq3XYINRkXfjvmb2FCv150+kf6NPXegu9MR5u5Dnfj1GbNuBtUH/J6BoJsPE883WLjPJI4beDkTAfdHOvGJs2afGFQf8HsWgm7+1kmu+yhR3fxt2fseZpVy8kYUmYMRKcr2TbVJCRd8ZFlzF+vtL7Ex1dVUmmpC05cPNZp2ORizf2dPpH9jzx3o7myEuftYJ359zqybQfUBv+cg6ObjxPMNFu5zieMGXs5FwP2JTnzik7NPDKoP+P0kgm7+3kmu+xRR3Sz2T6iS27G9srXF+6JUUilJz4QyRcoGrP1BZg29ZJmlzKJql4JtjZmnEGvRDrN/502kf2PPHejuPIS5+3Qnfv2ZWTeD6gN+P4Ogm88SzzdYuM8njht4OR8B9+c68YkLZp8YVB/wewGCbu6wRh+6+TxR3Sz2r12uZaZBSUIbHqO2sqhUldA+y8giK76EFJWyVvNkRLQ2wxvjFHj3Q5s56jnshRPp39hzB7q7EGHuvtCJX18062ZQfcDvRQi6+SLxfIOF+2LiuIGXixFwf6kTn7hk9olB9QG/lyDo5o6d5LovE9XNYv+4Y3B/ZWVZ6epLaVE/cKljzdJL4YtUTtpipNRGJ8lVjb7tDaLP0UrXhIbZv0sn0r+x5w50dynC3H2lE7/+6qybQfUBv19F0M3XiOcbLNyXEccNvFyGgPvrnfjEN2afGFQf8PsNBN3cqZNc902iulnsHzei1uCsEly6dqVXc8NNO7F3Bt7sMPKQeXFRSx2S0vBW1jVGIRKX1ScdfMHs3+UT6d/Ycwe6uxxh7r7ViV9fMetmUH3A7xUIuvk28XyDhftK4riBlysRcH+nE5+4avaJQfUBv1ch6GblTnLdd4nqZln/bNsEBNUwmpAaXJGCE0bImlhx2Ye2LfAmKBsc47IEn2AfoF1qfyVarj1m/66eSP/GnjvQ3dUIc/e9Tvz6+7NuBtUH/H4fQTc/IJ5vsHBfQxw38HINAu4fduITP5p9YlB9wO+PEHSzaie57sdEdbOsf0H5UEXbCXAemY6ZiWB8E0rkMWQdBbdMMRtyEJwrUZlpR/ec+VycCzwazP5dO5H+jT13oLtrEebuJ5349U9n3QyqD/j9KYJufkY832Dhvo44buDlOgTcP+/EJ66ffWJQfcDv9Qi6Wb2TXPcLorpZ7B8XSaoCb3XT5JLalzS+Hdu7qkJTCLOWF65lrdZ6JXPQOqmanGmH/rbtDGTA7N8NE+nf2HMHursBYe5+2Ylf/2rWzaD6gN9fIejm18TzDRbuG4njBl5uRMD9m0584qbZJwbVB/zehKCbNTvJdb8lqpvl/XO5tMN5E1WRrXbZ8NVUtMvtQq8uStYsQqnZmRhSO8VvJ/wNbrvO2x6TY0J9n5ObJ9K/secOdHczwtz9rhO//v2sm0H1Ab+/R9DNH4jnGyzctxDHDbzcgoD7j534xJ9mnxhUH/D7JwTdrN1JrvszUd0s6x/kfu9c1Cx7rq1UsUrh4cOFmba1FtP2AKw672xR2ttYis1SypSFCs6gvs/JrRPp39hzB7q7FWHu/tKJX/911s2g+oDfvyLo5m/E8w0W7tuI4wZebkPA/fdOfGJpxdknhtQH/ELvxtbNnTvJdXcgqpvF/gnFuTBSemFSTYYJV4OoNfvKPIu8aHhfaxaczZZzJ3W7+Ns0llU71Ve+He5j9m+FifRv7LkD3a2AMHd3XLGPuVtx1s2g+oDfFRF0c6cVaecbLNwrEccNvKyEgHvlTnxildknBtUH/K6CoJu7dpLrViWqm2X9y9q0/O+dqDJX6YKs3NfouEqScVkV9zGwEp1iMgqbWLv8a3UytfBUlUE9h11tIv0be+5Ad6shzN3qnfj1GrNuBtUH/K6BoJs1iecbLNxrEccNvKyFgHvtTnxindknBtUH/K6DoJu7dZLr7kxUN4v945XxUh2zRiavq5ZJScUbbi+zN1aGUqpoO4PKQ+De22ysjVrb6I0XxQXM/t1lIv0be+5Ad3fB2E914tfrzroZVB/wuy6GXxPPN1i41yOOG3hZDwH33TvxifVnnxhUH/C7PoZuOsl19yCqm8X+caaTFu2k3jGuhS2GRSYNT+1xVkcdrM8iJ+MEzy5woV32zJSsmsBsaaf5mP3bYCL9G3vuQHcbIMzdPTvx6w1n3QyqD/jdEEE39yKeb7Bw35s4buDl3gi479OJT2w0+8Sg+oDfjRB0c49Oct19iepmWf9kjprpwJIUKTbBBOa9dD4J7li7luukE7ZGxduJfslOZeesMbkqlYxkFvV9iTeeSP/GnjvQ3cYIc3e/Tvx6k1k3g+oDfjdB0M39iecbLNybEscNvGyKgPsBnfjEZrNPDKoP+N0M47pBJ7nugUR1c89l749jRLHStaP7HE2C+K+yt8IKr5TgKXsdahCqKstY4lLIEJ1MMjATUpECs38Pmkj/xp470N2DEObuwZ349eazbgbVB/xujqCbhxDPN1i4tyCOG3jZAgH3QzvxCTb7xKD6gF+GcV2/k1zHiepmWf9KMS7JIl3iXjEpvVeJZZVtzAU+X7ippv1LiNBO9z3X1Ymkg4xMCRGzR72/Tkykf2PPHehOIMyd7MSv1aybQfUBvwpBN5p4vsHCbYjjBl4MAm7biU+42ScG1Qf8Oozz+05ynSeqm8X+iQIvlW4iESypdoqfRWUh+GIU99V6YUJMWXujmVPCi9AenbN1bXjbWb9nqNfrtpxI/8aeO9Ddlghz97BO/HqrWTeD6gN+t0LQzcOJ5xss3I8gjht4eQQC7kd24hOPmn1iUH2384ugm/t2kuseTVQ3i/27/R1wsuRZBOl4E0phwQvFkzJC+CBEze04X6iGTbVrvKw0PWVWS9TOaBMqZv+2nkj/xp470N3WCHP3mE78eptZN4PqA363QdDNY4nnGyzc2xLHDbxsi4D7cZ34xHazTwyqD/jdDuP+7U5y3eOJ6mZZ/2KQvjLeZBKiCTZVI7jXwmpRUy7KGWuzrVLkdoJf2pXgElJVXqukSzW499dtP5H+jT13oLvtEebuCZ349Q6zbgbVB/zugKCbJxLPN1i4dySOG3jZEQH3kzrxiZ1mnxhUH/C7E8brqzrJdU8mqpvF/gmfGItMt+N7uHrb9BNzYibyYmWtukX/qmWu3lSnTNsxuMS0FZnzmkJ1LmL2b+eJ9G/suQPd7Ywwd0/pxK93mXUzqD7gdxcE3TyVeL7Bwr0rcdzAy64IuJ/WiU/sNvvEoPqA390wXkfdSa57OlHdLOtfNIIx5xssFkwy1quaKk8i8sibbGSwXCbPdHAx8No6oavVjNfCg2YR9fMmdp9I/8aeO9Dd7ghz94xO/HqPWTeD6gN+90DQzTOJ5xss3HsSxw287ImA+1md+MRes08Mqg/43QtBNw/sJNcForpZ7J+IyUjfRNLwWMnbVd4skqnS86yUd0V6kaLVJaeYdVKJ1SYgYXK78GvgjRAx+xcn0r+x5w50FxHmLnXi13nWzaD6gN+MoJtCPN9g4a7EcQMvFQH3szvxib1nnxhUH/C7N4JuHtxJrnsOUd0s9k8E56t0pSFlCV5lw4Vl7WKvsbn9xxb+udJM5nZp15pYZbJth8B4bteDZXBKacz+7TOR/o09d6C7fRDm7rmd+PW+s24G1Qf87ougm+cRzzdYuPcjjht42Q8B9/M78Yn9Z58YVB/wuz+Cbh7SSa57AVHdLPaPt4u2JRdbSomqwEukpWuiqSGZLDQLWjGt2x+GzFkxPspgGkhmTQrOOoN6DnvARPo39tyB7g5AmLsXduLXB866GVQf8Hsggm5eRDzfYOE+iDhu4OUgBNwv7sQnDp59YlB9wO/BCLp5aCe57iVEdbOsf6ldsIU3v4lNGiJYJTnXsWgpfNZKuyy8Y4K5dgW4+hyS4qZd7hVG8+pjERGzf4dMpH9jzx3o7hCEuXtpJ3596KybQfUBv4ci6OZlxPMNFu7DiOMGXg5DwP3yTnzi8NknBtUH/B6OoBveSa57BVHdLPavYWCyiOykKhyifpEy+RCtMEEWq3NmOWQfawk8KCmM5d63hwklfUOKmuuOmEj/xp470N0RCHP3yk78+shZN4PqA36PRNDNq4jnGyzcRxHHDbwchYD71Z34xNGzTwyqD/g9GkE3spNc9xqiupHL7svUVjjOU2jCCZpz1i7o2oZZpZKlESWWmm3KvHDXNg3W+OKV1A1sqUkX1PvrjplI/8aeO9DdMQhz99pO/PrYWTeD6gN+j0XQzeuI5xss3McRxw28HIeA+/Wd+MTxs08Mqg/4PR5BN7qTXPcGorrRy8/vRRONtt7XIkpwIhmbWHCZOSNjO7pPrLRLurbtGrhv2wPFRPuGuahlNVFh9u+EifRv7LkD3Z2AMHdv7MSvT5x1M6g+4PdEBN28iXi+wcJ9EnHcwMtJCLjf3IlPvGX2iUH1Ab9vQdCN7STXvZWobpb1TzFbtIrehIZMJsN8DdJ6G4WQycosDAvS6JC1i0I7z4M2hgkrmDcxo16vO3ki/Rt77kB3JyPM3ds68eu3z7oZVB/w+3YE3byDeL7Bwv1O4riBl3ci4H5XJz5xyuwTg+oDfk9B0I3vJNe9m6huFvvHg2wXcbWOrKkkt7P75IQQyXurhIqJK9au7IqSY1XRhaYZlXzRToqYQyqeY/bvPRPp39hzB7p7D8LcvbcTv37frJtB9QG/70PQzfuJ5xss3KcSxw28nIqA+wOd+MRps08Mqg/4PQ1BNw/rJNd9kKhuHrbsc0qMaKrRxfi2L+A26XYdNygfeVNJyM5rrtq3rOEvFl46HXXW2jvFI9yWmTH7d/pE+jf23IHuTkeYuw914tdnzLoZVB/wewaCbj5MPN9g4T6TOG7g5UwE3B/pxCfOmn1iUH3A71kIunl4J7nuo0R18/Bl5/fKSe0Yhw8h0UJHlQR3WrYLv7ppSLlQldHFV+tz8Zmb9nj4NBMtc7A+WMz+nT2R/o09d6C7sxHm7mOd+PU5s24G1Qf8noOgm48TzzdYuM8ljht4ORcB9yc68YlPzj4xqD7g95MIunlkJ7nuU0R1s9g/kVWoJdtgmSvaN7BOZWuM8KKK1GJ/0tnphs5wZlXWPmRZNS9eGh/a4zH7d95E+jf23IHuzkOYu0934tefmXUzqD7g9zMIuvks8XyDhft84riBl/MRcH+uE5+4YPaJQfUBvxcg6ObRneS6zxPVzWL/eGIlspby27m8M6YIy1MWLehXbqttV4FVDRHO+Jlz0etiZU7t3D57kRrsYDD7d+FE+jf23IHuLkSYuy904tcXzboZVB/wexGCbr5IPN9g4b6YOG7g5WIE3F/qxCcumX1iUH3A7yUIunlMJ7nuy0R1s9g/YSxraiiqChlsts6EzNs/o9QyiOqiE8L4ZKN2IVqWLRzbK24afKky7ufDXjqR/o09d6C7SxHm7iud+PVXZ90Mqg/4/SqCbr5GPN9g4b6MOG7g5TIE3F/vxCe+MfvEoPqA328g6OaxneS6bxLVzbL+qdI2AxnCPoucu3aYLzkzoQidmFI2JHhZTU4mG5FqsbUkka33Mtd2cVgIzP5dPpH+jT13oLvLEebuW5349RWzbgbVB/xegaCbbxPPN1i4rySOG3i5EgH3dzrxiatmnxhUH/B7FYJuHtdJrvsuUd0s61+uUkqdA5e1KlONZl5Xb3Xm2jpnhOKhpFSrdDX7GIMXrSnVeeOzLcxj9u/qifRv7LkD3V2NMHff68Svvz/rZlB9wO/3EXTzA+L5Bgv3NcRxAy/XIOD+YSc+8aPZJwbVB/z+CEE3j+8k1/2YqG4ev+y+zFqrEdELJ0piOvIaVNsH+GDaNqDE4kMysgGWWUTOilLRF1YL96Vd5i0Fs3/XTqR/Y88d6O5ahLn7SSd+/dNZN4PqA35/iqCbnxHPN1i4ryOOG3i5DgH3zzvxietnnxhUH/B7PYJuntBJrvsFUd0s658rqQjlmhJS+39up/nG+6hTZjZ5z9plXWsFjyFqH422MXLpSsNcijFeZcz+3TCR/o09d6C7GxDm7ped+PWvZt0Mqg/4/RWCbn5NPN9g4b6ROG7g5UYE3L/pxCdumn1iUH3A700IunliJ7nut0R1s9g/kXiIjudomI3Bmhyr5bVh0iI5bWLlTrZzfO94ktFkXrPkkbftArOuaov6eRM3T6R/Y88d6O5mhLn7XSd+/ftZN4PqA35/j6CbPxDPN1i4byGOG3i5BQH3HzvxiT/NPjGoPuD3Twi6eVInue7PRHWzrH88F1NdO6lv/ytS81hVCiELL2N2prTflGqka5d4uU7RtdN9JQprD4uxfesw+3frRPo39tyB7m5FmLu/dOLXf511M6g+4PevCLr5G/F8g4X7NuK4gZfbEHD/vROfWLrT7BND6gN+oXdj6+bJneS6OxDVzWL/hMzZRW1NDcIZ2U7qjcpGJmtrdqIGw3Ow3GopnYCPJnHCcFti1irEEhXq+9etMJH+jT13oLsVEObujnfqY+5WnHUzqD7gd0UE3dzpTrTzDRbulYjjBl5WQsC9cic+scrsE4PqA35XQdDNUzrJdasS1c1i/7jx8L7VRXMdRSrF5XZh1/t2VddyYaVpDw+2elGjVEkWWbUUubQ/lSGktinA7N9qE+nf2HMHulsNYe5W78Sv15h1M6g+4HcNBN2sSTzfYOFeizhu4GUtBNxrd+IT68w+Mag+4HcdBN08tZNcd2eiulnWv5Kqa8i8K6CH4H1oGmIui3aMz2vwomjGXTvlT877rLXKiecapE4lsoDav7tMpH9jzx3o7i4Ic3fXTvx63Vk3g+oDftdF0M3diOcbLNzrEccNvKyHgPvunfjE+rNPDKoP+F0fQTdP6yTX3YOobpb1LyeWTbEm1BiktTkbL0tWSdmgqq+l2ODaJiFXnasRNTNTRXUW7uUsPKHeX7fBRPo39tyB7jZAmLt7duLXG866GVQf8Lshgm7uRTzfYOG+N3HcwMu9EXDfpxOf2Gj2iUH1Ab8bIejm6Z3kuvsS1c2y/mWXmdOWa+mTcU06OWQRjGkn9Z5nKaRX7SqwDW1T4IONRZTEVXZeMhejyZj923gi/Rt77kB3GyPM3f068etNZt0Mqg/43QRBN/cnnm+wcG9KHDfwsikC7gd04hObzT4xqD7gdzME3Tyjk1z3QKK6Wewft5lbVqyEWy+LFyJ5qSp8ZHCWSbjqdKlcRcGTlVq1vy28g2N+a7xtOwaF2b8HTaR/Y88d6O5BCHP34E78evNZN4PqA343R9DNQ4jnGyzcWxDHDbxsgYD7oZ34BJt9YlB9wC9D0M0zO8l1nKhulvXPl2wky4q1q7nwaXNBqgZbc514itK4ds2X6aRyycLkKp3RIgvPojC1XRuumP0TE+nf2HMHuhMIcyc78Ws162ZQfcCvQtCNJp5vsHAb4riBF4OA23biE272iUH1Ab8OQTfP6iTXeaK6WeyfiFo67pXMcGYvY2baB2WVjVbUxLmpzPukTFstc3Kc5xyVYhXezrph5gWzf1tOpH9jzx3obkuEuXtYJ3691aybQfUBv1sh6ObhxPMNFu5HEMcNvDwCAfcjO/GJR80+Mai+2/lF0E3oJNc9mqhuwvL3PWw7gOKdLd7oBBuAxIQWxdscXazROmNcbjsDn3I1yYJmWFNbzFpEGTH7t/VE+jf23IHutkaYu8d04tfbzLoZVB/wuw2Cbh5LPN9g4d6WOG7gZVsE3I/rxCe2m31iUH3A73YIukmd5LrHE9XNYv944C45byoXKmXlBK+xMBeScaxpRhqRuJZKGe5TqcwKZ1VV0np47XUVErN/20+kf2PPHehue4S5e0Infr3DrJtB9QG/OyDo5onE8w0W7h2J4wZedkTA/aROfGKn2ScG1Qf87oSgm9JJrnsyUd2UZe972MJ+qKyEIlJte4JqYjvBjzUruEmTJ9XA21hrNd5wCS+f9laI0h6jm25Q+7fzRPo39tyB7nZGmLundOLXu8y6GVQf8LsLgm6eSjzfYOHelThu4GVXBNxP68Qndpt9YlB9wO9uCLp5die57ulEdbPYP55r1s5aYUpSSmijS1S2tmu9sp3iMyNVNNqIzKNh3AuvLG+qcsayEBTjqK+H3X0i/Rt77kB3u2O8Dr0Tv95j1s2g+oDfPTBe50Y832Dh3pM4buBlT4z73zvxib1mnxhUH/C7F4JuntNJrgtEdbPYP65s8EzFlLkNshpTYrbwkSVcWK+Zhe2DYcIpEZiyTTg1c+6z5CVX6QVqrosT6d/Ycwe6ixj3P3Ti13nWzaD6gN+Mcb5CPN9g4a7EcQMvFeO6Syc+sffsE4PqA373RtDNczvJdc8hqpvl/TOCc6OKi004yhre8BYRQsw+8GBsSYnp6oWJJekYQyrRatHO801pf89g9m+fifRv7LkD3e2DMXed+PW+s26G1df6ti+Cbp5HPN9g4d6POG7gZT8E3M/vxCf2n31iUH3A7/4YPtFJrnsBUd0s9k84VlMqnjdpsGgamFJkMcFJF2JMvNp23VcV5bSMQmRmbNCm6uKZU77hxuzfARPp39hzB7o7AGHuXtiJXx8462ZQfcDvgQi6eRHxfIOF+yDiuIGXgxBwv7gTnzh49olB9QG/B2PsBzrJdS8hqpvF/omsfGYyRBOt4srrorJNsTT9BJMqq8yEElyTinCZy6xtNYG1RyVnXGYRs3+HTKR/Y88d6O4QhLl7aSd+feism0H1Ab+HIujmZcTzDRbuw4jjBl4OQ8D98k584vDZJwbVB/wejqCbF3SS615BVDeL/RNB+2iK4sxpkb0xpp3oe25b3uehSleVddEaJkuURVUh28bBGymzEyblgnq97oiJ9G/suQPdHYEwd6/sxK+PnHUzqD7g90gE3byKeL7Bwn0UcdzAy1EIuF/diU8cPfvEoPqA36MxzoM6yXWvIaqbFy57fxxrnazB12qjNLld3oUD+mJ0qsk1cbBoWYb3s46ah6it0kXXwnOSOvvIMft3zET6N/bcge6OQZi713bi18fOuhlUH/B7LIJuXkc832DhPo44buDlOATcr+/EJ46ffWJQfcDv8Rj3a3SS695AVDcvWnZ+bzIvtjDpa7j9m5hdLcYX3tSTQjbceJnaQb5u4JVTlnseQxG1SqWiwOzfCRPp39hzB7o7AWHu3tiJX58462ZQfcDviQi6eRPxfIOF+yTiuIGXkxBwv7kTn3jL7BOD6gN+34JxX2Ynue6tRHWzrH81tEu8uR3YF66KS1qyBsCHUNsFXedziFHmxISptaTI2mG/zCY2waTWDmYtZv9Onkj/xp470N3JCHP3tk78+u2zbgbVB/y+HUE37yCeb7Bwv5M4buDlnQi439WJT5wy+8Sg+oDfUxB085JOct27iepmWf9K04A2UtegGyrmhE8NlBRJScNjDbbkmqtikWmuEmM5y2CldK0nlXvUzxF7z0T6N/bcge7egzB37+3Er98362ZQfcDv+xB0837i+QYL96nEcQMvpyLg/kAnPnHa7BOD6gN+T8N4XV4nue6DRHWz2D8hIyvB8uhizDJFI+B1N0ULXXVyUeoUa8lOMNghCKngtTnKaJ1ytbxdHMbs3+kT6d/Ycwe6Ox1h7j7UiV+fMetmUH3A7xkIuvkw8XyDhftM4riBlzMRcH+kE584a/aJQfUBv2dhvG6+k1z3UaK6edmy19ukkrUVOdYsjFHaeCZZTVV6zniDJar1TTuxyHZZlyvnVY012QY/NA1VzP6dPZH+jT13oLuzEebuY5349TmzbgbVB/yeg6CbjxPPN1i4zyWOG3g5FwH3JzrxiU/OPjGoPuD3kwi6eXknue5TRHWzrH8yyds/SThzkUMVSohaYuY6KC14le3irvZM2yRCrblBN8nYGmTbKqTUtgeY/TtvIv0be+5Ad+chzN2nO/Hrz8y6GVQf8PsZBN18lni+wcJ9PnHcwMv5CLg/14lPXDD7xKD6gN8LEHTzik5y3eeJ6maxf9xm047l2xZAeGl8Yr7JQ7dDfKuliK7JyMGLb6rJ2We4TdMwGYMzKXqhW3Mw+3fhRPo39tyB7i5EmLsvdOLXF826GVQf8HsRgm6+SDzfYOG+mDhu4OViBNxf6sQnLpl9YlB9wO8lCLp5ZSe57stEdbOsf14zzWQDorg0RSUro2pXeENkzMVqhA5WJs1DU1OxtnqfDDMp2HZ92MiMmusunUj/xp470N2lCHP3lU78+quzbgbVB/x+FUE3XyOeb7BwX0YcN/ByGQLur3fiE9+YfWJQfcDvNxB086pOct03iepmsX+cpcDa0X3wOibunW1ikFZXbQx3QhlZWPKiBC5ErkY5XXlSRQdvjY9SJMz+XT6R/o09d6C7yxHm7lud+PUVs24G1Qf8XoGgm28TzzdYuK8kjht4uRIB93c68YmrZp8YVB/wexWCbl7dSa77LlHdLPZP+Gpk8lKXWoRQRUiddVQNq9PWNXlEodsewQepRFaBZd+2Cd6VarXN0aB+3sTVE+nf2HMHursaYe6+14lff3/WzaD6gN/vI+jmB8TzDRbua4jjBl6uQcD9w0584kezTwyqD/j9EYJuXtNJrvsxUd0s9o8XLlxDVmptupA8cuti8tqmxJLigWcrpGXawnm9qZl5VqJMRhoT27G+xuzftRPp39hzB7q7FmHuftKJX/901s2g+oDfnyLo5mfE8w0W7uuI4wZerkPA/fNOfOL62ScG1Qf8Xo+gm9f+l3Id+8++xKoj9nK1Eft3bB/946uPyMU3Vx+vf6/rpH8jzglf1Mx//LmZnezLfjGi74+oGd5L/26YSP/GXjdBdzcgrJu/7CRv/WrWzaD6gN9fIejm18T3J1i4bySOG3i5EQH3bzrxiZtmnxhUH/B7E4Ju3tjJvuybI+7BXztiLj6xk33FiPtH/sYR+/emTnLxb0f0rRE1wxf7J4ooMcJVJOFNNDI7V+A+sMq8NSH7dnGJZ1ViOyAUPOfcHg0v1rTFstCOC1HPe26eSP/G9n3Q3c0Ivv+7TvLC72fdDKoP+P09gm7+QDxfY+G+hThu4OUWBNx/7MQn/jT7xKD6gN8/IejmrRPMxW8dMRef3Eku/jPRuVvsn+CxJq5V1JFZnoXIzHCmjZFaS8d4ddolXoXkTLCokvA8WOGzEY5nqVA/7+nWifRvbN8C3d2K4Ft/6WS9++usm0H1Ab9/RdDN34jnQyzctxHHDbzchoD77534xNJKs08MqQ/4hd6NrZt3TDAXv2PEXPzOTnLxHYjO3WL/uDCpBqlFZEVYxpUSUZrCkqjJOeFsqlnGWlJqSEWoiRVZrMuu5KhCdpj9W2Ei/Rvbt0B3KyD41h1X6mPuVpx1M6g+4HdFBN3caWTd9IJ7JeK4gZeVEHCv3IlPrDL7xKD6gN9VEHTz7gnm4nePmIvf00kuXpXo3C3rn2Q+W2ZsiEbnwoP3tQhZlXaZxSQrd0n7aIwSpSrXBs9YXyq3KRovHOr73K02kf6N7Vugu9UQfGv1Tta7NWbdDKoP+F0DQTdrEs+HWLjXIo4beFkLAffanfjEOrNPDKoP+F0HQTfvn2Aufv+IufjUTnLxnYnO3WL/uFdJGS8V894Yb1gszmkuUy1S+LYd5UJXy6V3wTpRlPJW1tjmT1nvIu714rtMpH9j+xbo7i4IvnXXTta7dWfdDKoP+F0XQTd3I54PsXCvRxw38LIeAu67d+IT688+Mag+4Hd9BN18cIK5+IMj5uLTO8nF9yA6d8v6p4NT3jgVk3YpsWyKr5L7qHIowuTILbeyndQY1v5z9tYVxTPzwepg2uMw+7fBRPo3tm+B7jZA8K17drLebTjrZlB9wO+GCLq5F/F8iIX73sRxAy/3RsB9n058YqPZJwbVB/xuhKCbD08wF394xFx8Zie5+L5E526xf7xtKmHE2hZUadm+EdWzrDi8BrZIyaIITjgTgwpt2FJom9GYU/VSaKki7vtRbDyR/o3tW6C7jRF8636drHebzLoZVB/wuwmCbu5PPB9i4d6UOG7gZVME3A/oxCc2m31iUH3A72YIuvnoBHPxR0fMxWd3kosfSHTulvXPSpMMS1n6mrlRPivXMKrqgynJxzZqztcocmFBZltKiEXJ1oeoDbM1YPbvQRPp39i+Bbp7EIJvPbiT9W7zWTeD6gN+N0fQzUOI50Ms3FsQxw28bIGA+6Gd+ASbfWJQfcAvQ9DNxyeYiz8+Yi4+t5NczInO3WL/RDtu8ZYHn0XiGc5orJLwetZquPIi8phlUkY7lZg1wZqkZJIp82CV1Vxg9k9MpH9j+xboTiD4luxkvVOzbgbVB/wqBN1o4vkQC7chjht4MQi4bSc+4WafGFQf8OsQdPOpCebiT42Yi8/rJBd7onO3rH9BSisz1zWYnIoQvDophElMtNOa6kIJOtVkclDJV+UdDzm0YWz7UVa1KZj923Ii/Rvbt0B3WyL41sM6We+2mnUzqD7gdysE3TyceD7Ewv0I4riBl0cg4H5kJz7xqNknBtV3O78IuvnsBHPxZ0fMxed3kosfTXTuFvsnom0XZl0RsarSttBt8krOse1IFfcsW5mE8zm1Rugoq1GlTaiLmZU2mMlY1OvFW0+kf2P7FuhuawTfekwn6902s24G1Qf8boOgm8cSz4dYuLcljht42RYB9+M68YntZp8YVB/wux2Cbj4/wVz8+RFz8YWd5OLHE527Zf2LQpWqTDt34aVkL3OWxkglqk9BlRKjVT650I5zmLbJMZ61dMkmZgzc7Y/Zv+0n0r+xfQt0tz2Cbz2hk/Vuh1k3g+oDfndA0M0TiedDLNw7EscNvOyIgPtJnfjETrNPDKoP+N0JQTdfnGAu/uKIufjiTnLxk4nO3bL+6cwLC0lb036THFfRCK65kdKHwoPwPNlcpYm6ZpMqi6rI5FMWukiGe71454n0b2zfAt3tjOBbT+lkvdtl1s2g+oDfXRB081Ti+RAL967EcQMvuyLgflonPrHb7BOD6gN+d0PQzZcnmIu/PGIuvrSTXPx0onO32D9heaqxOle8Vaoh9KbYIrJxVrfdZxtLVoxgXDHeplPq4nWwqQjpWUyaVcz+7T6R/o3tW6C73RF86xmdrHd7zLoZVB/wuweCbp5JPB9i4d6TOG7gZU8E3M/qxCf2mn1iUH3A714IuvnaBHPx10bMxZd1kosD0bm7bNnn6RjJfOWZW5at4iHyVDxL0lvbxs3WaFMuybokrXMiehfa1tR4bRKXuaDm4jiR/o3tW6C7iOBbqZP1Ls+6GVQf8JsRdFOI50Ms3JU4buClIuB+dic+sffsE4PqA373RtDNNyeYi785Yi6+vJNc/Byic7fYPy5s4pybdlCjE5PJVpOdVNxml3iUjrnqRSnceKGCVsyrWNs/rODFF1VRP9djn4n0b2zfAt3tg+Bbz+1kvdt31s2g+oDffRF08zzi+RAL937EcQMv+yHgfn4nPrH/7BOD6gN+90fQzbcnmIu/PWIuvrKTXPwConO32D8ea7WOKVuKsVm6Nls1pzZg1QcRA2tzKJXzIWVplNCVhyJuP7ER3gmDm4sPmEj/xvYt0N0BCL71wk7WuwNn3QyqD/g9EEE3LyKeD7FwH0QcN/ByEALuF3fiEwfPPjGoPuD3YATdfHeCufi7I+biqzvJxS8hOnfL+meSzcnGGIrhuqbKnTdVRJejzV4kpnPiJfDkuFTF52hq1s4ZK5KWxQfM/h0ykf6N7Vugu0MQfOulnax3h866GVQf8Hsogm5eRjwfYuE+jDhu4OUwBNwv78QnDp99YlB9wO/hCLr5wQRz8Q9GzMXXdJKLX0F07q5Zdk6T2340xcCtLtWaHGtKPlmnvTAxSq98cLYkqxtWoXXbpdpgVPQ8lTasqNeLj5hI/8b2LdDdEQi+9cpO1rsjZ90Mqg/4PRJBN68ing+xcB9FHDfwchQC7ld34hNHzz4xqD7g92gE3fx4grn4xyPm4ms7ycWvITp31y573/CsUk7eiCJzMCJF2b6pNinhgo8sa+5ivf0lrqa6mkqbutDm04caTTvOwezfMRPp39i+Bbo7BsG3XtvJenfsrJtB9QG/xyLo5nXE8yEW7uOI4wZejkPA/fpOfOL42ScG1Qf8Ho+gm59NMBf/bMRcfF0nufgNROdusX9ClZylU7a27WVRKqmUpGdCmSJlA9b+ILOGXrLMUmZRtaMcW2PmKcRatMPs3wkT6d/YvgW6OwHBt97YyXp34qybQfUBvyci6OZNxPMhFu6TiOMGXk5CwP3mTnziLbNPDKoP+H0Lgm5+McFc/IsRc/ENneTitxKdu8X+teMWZhqUJLThMWori0pVCe2zjCyy4ktIUSlrNU9GRGszvDFigXcPt5mj3kdx8kT6N7Zvge5ORvCtt3Wy3r191s2g+oDftyPo5h3E8yEW7ncSxw28vBMB97s68YlTZp8YVB/wewqCbn49wVz86xFz8Y2d5OJ3E527xf5xx+D+/Mqy0tWX0raagUsda5ZeCl+kctIWI6U2OkmuavRtbxp9jla6NqiY/XvPRPo3tm+B7t6D4Fvv7WS9e9+sm0H1Ab/vQ9DN+4nnQyzcpxLHDbycioD7A534xGmzTwyqD/g9DUE3v51gLv7tiLn45k5y8QeJzt1i/7gRtQZnleDStZMazQ03LlZn4M3CIw+ZFxe11CEpDR+lU2MUInFZfdLBF8z+nT6R/o3tW6C70xF860OdrHdnzLoZVB/wewaCbj5MPB9i4T6TOG7g5UwE3B/pxCfOmn1iUH3A71kIuvnDBHPxH0bMxbd0kos/SnTulvXPtk1oUA2jCanBFSk4YYSsiRWXfWjbUm+CssExLkvwCfah2qX2V6Ll2mP27+yJ9G9s3wLdnY3gWx/rZL07Z9bNoPqA33MQdPNx4vkQC/e5xHEDL+ci4P5EJz7xydknBtUH/H4SQTd/nmAu/vOIufjWTnLxp4jO3bL+BeVDFW0nynlkOmYmgvFt0CKPIesouGWK2ZCD4FyJykxRhTOfi3OBR4PZv/Mm0r+xfQt0dx6Cb326k/XuM7NuBtUH/H4GQTefJZ4PsXCfTxw38HI+Au7PdeITF8w+Mag+4PcCBN38bYK5+G8j5uLbOsnFnyc6d7cte3/EJFWBtzps45balzRe+OKqCm3CmLW8cC1rtdYrmYPWSdXkDNPStp2pDJj9u3Ai/Rvbt0B3FyL41hc6We8umnUzqD7g9yIE3XyReD7Ewn0xcdzAy8UIuL/UiU9cMvvEoPqA30sQdHOHNaeXixcx/6f9W2HNPubuy0Tnbnn/XC66HdFEVWSrXTZ8NRXtcjuo0UXJmkUoNTsTQ5I6xKIb3HZO0x6TY0J9n7ZLJ9K/sX0LdHcpgm99pZP17quzbgbVB/x+FUE3XyOeD7FwX0YcN/ByGQLur3fiE9+YfWJQfcDvNxB0c6cJ5uI7jZiLV+okF3+T6Nwt6x/sO71zUbPsubZSxSqFN9lJpm2txbQ9KKvOO1uU9jaWYrOUMmWhgjOo79N2+UT6N7Zvge4uR/Ctb3Wy3l0x62ZQfcDvFQi6+TbxfIiF+0riuIGXKxFwf6cTn7hq9olB9QG/VyHoZtUJ5uJVR8zFq3WSi79LdO4W+ycU58JI6YVJNRkmXA2i1uwr8yzyouFzdVhwNlvOndTt8KbNaFaWKeUFt5j9u3oi/Rvbt0B3VyP41vc6We++P+tmUH3A7/cRdPMD4vkQC/c1xHEDL9cg4P5hJz7xo9knBtUH/P4IQTdrTjAXrzliLl6rk1z8Y6Jzt6x/WZu2//ROVJmrdEFW7mt0XCXJuKyK+xhYiU4xGYVNrB3fWJ1MLTxVZVDvo7h2Iv0b27dAd9ci+NZPOlnvfjrrZlB9wO9PEXTzM+L5EAv3dcRxAy/XIeD+eSc+cf3sE4PqA36vR9DNnSeYi+88Yi6+Sye5+BdE526xf7wyXqpj1sjkddUyKal4w+1l9sbKUEoVbWdaeQjce5uNtVFrG73xoriA2b8bJtK/sX0LdHcDgm/9spP17lezbgbVB/z+CkE3vyaeD7Fw30gcN/ByIwLu33TiEzfNPjGoPuD3JgTd3G2CufhuI+bi9TrJxb8lOneL/eNMJy20baPHtbDFsMik4ak9zuqog/VZ5GSc4NkFLrTLnpmSVRtQW2xE/VyPmyfSv7F9C3R3M4Jv/a6T9e73s24G1Qf8/h5BN38gng+xcN9CHDfwcgsC7j924hN/mn1iUH3A758QdHOPCebie4yYizfoJBf/mejcLeufzFEzHViSIsU2cIF5L51PgjvWzmKcdMLWqHj2tWSnsnPWmFyVSkYyi/q5HrdOpH9j+xbo7lYE3/pLJ+vdX2fdDKoP+P0rgm7+RjwfYuG+jThu4OU2BNx/78QnllaefWJIfcAv9G5s3dxrgrn4XiPm4nt3kovvQHTuFvvHhRHFSlely9Ek2H6q7K2wwisleMpehxqEqsoylrgUMkQnkwzMhFSkwOzfChPp39i+BbpbAcG37rhyH3O34qybQfUBvysi6OZOI+umF9wrEccNvKyEgHvlTnxildknBtUH/K6CoJv7TjAX33fEXLxxJ7l4VaJzt6x/pRiXZJEuca+YlN6rxLLKNuYidaxt6tq/hAheV891dSLpICNTQsTsUe8vXm0i/Rvbt0B3qyH41uqdrHdrzLoZVB/wuwaCbtYkng+xcK9FHDfwshYC7rU78Yl1Zp8YVB/wuw6Cbu4/wVx8/xFz8aad5OI7E527xf6JAm/10oZMsKRsdVlUFoIvRnFfrRcmxJS1N5o5JbwI7dE5W8eYtcV4hnq9+C4T6d/YvgW6uwuCb921k/Vu3Vk3g+oDftdF0M3diOdDLNzrEccNvKyHgPvunfjE+rNPDKoP+F0fQTcPnGAufuCIufhBneTiexCdu8X+3f4OiFnyLIJ0vA1aYcELxZMyQvggRM1eOqEaNtXOaFhp85hZLVE7o02omP3bYCL9G9u3QHcbIPjWPTtZ7zacdTOoPuB3Q4z7BonnQyzc9yaOG3i5NwLu+3TiExvNPjGoPuB3IwTdPGSCufghI+biLTrJxfclOnfL+heD9JXxNmYhmmBTNYJ7LawWNeWinLE22ypFrsqWdpJTQqrKa5V0qQb3/uKNJ9K/sX0LdLcxgm/dr5P1bpNZN4PqA343wTgfJZ4PsXBvShw38LIpAu4HdOITm80+Mag+4HczBN3wCeZiPmIuFp3k4gcSnbvF/gmfGItMu8Th9KXNX8yJmciLlbXqtvWsWubqTXXKtB2rS0xbkTmvKVTnImb/HjSR/o3tW6C7ByH41oM7We82n3UzqD7gd3OM60DE8yEW7i2I4wZetkDA/dBOfILNPjGoPuCXIehGTzAX6xFzsekkF3Oic7esf9EIxpxvsFgwyVivaqo8icgjb2Mng+UyeaaDi4HX1gldrWa8Fh40i6ifdycm0r+xfQt0JxB8S3ay3qlZN4PqA34VxnpHPB9i4TbEcQMvBgG37cQn3OwTg+oDfh2CbvwEc7EfMRdv2Uku9kTnbrF/IiYjfRuyhsdK3k5pskimSs+zUt4V6UWKVpecYtZJJVbbAAqT28GNgTcSx+zflhPp39i+BbrbEsG3HtbJerfVrJtB9QG/WyHo5uHE8yEW7kcQxw28PAIB9yM78YlHzT4xqL7b+cXwiQnm4oePmIsf0UkufjTRuVvsnwjOV+lKQ8oSvMqVC8vaYY2xuf3HtvnkSjOZ29GMNbHKZNsOlfHcznNkcEppzP5tPZH+je1boLutEXzrMZ2sd9vMuhlUH/C7DYJuHks8H2Lh3pY4buBlWwTcj+vEJ7abfWJQfcDvdgi6efQEc/GjR8zFW3eSix9PdO4W+8fboUvJxZZSoirwFi/StaGrIZksNAtaMa3bH4bMWTE+ymAaSGZNCs46g3ofxfYT6d/YvgW62x7Bt57QyXq3w6ybQfUBvzsg6OaJxPMhFu4dieMGXnZEwP2kTnxip9knBtUH/O6EsX+eYC5+7Ii5eNtOcvGTic7dsv6lduACb34Y22iJYJXkXMeipfBZK+2y8I4J5toJTvU5JMVNO64RRvPqYxERs387T6R/Y/sW6G5nBN96Sifr3S6zbgbVB/zugqCbpxLPh1i4dyWOG3jZFQH30zrxid1mnxhUH/C7G4JuHj/BXPz4EXPx9p3k4qcTnbvF/jUMTBaRnVSFw1azSJl8iFaYIIvVObMcso+1BB6UFMZy79vDhJK+IUXNxbtPpH9j+xbobncE33pGJ+vdHrNuBtUH/O6BoJtnEs+HWLj3JI4beNkTAfezOvGJvWafGFQf8LsXxrnSBHPxE0fMxTt2kosD0bnbcdl9/doKx3kKbfCC5py1AxnbMKtUsjSixFKzTZkX7tqm1RpfvJK6gS016YJ6f3GcSP/G9i3QXUTwrdTJepdn3QyqD/jNCLopxPMhFu5KHDfwUhFwP7sTn9h79olB9QG/eyPo5skTzMVPHjEX79xJLn4O0bnbefn9S6INnbbe1yJKcCIZm1hwmTkjoy4lsdKOZGzbtXLftqeKifYNc1HLaqLC7N8+E+nf2L4FutsHwbee28l6t++sm0H1Ab/7IujmecTzIRbu/YjjBl72Q8D9/E58Yv/ZJwbVB/zuj3G/1QRz8VNHzMW7dpKLX0B07pb1TzFbtIrehIZMJsN8DdJ6G4WQycosDAvS6JC1i0I7z4M2hgkrmDcxo14vPmAi/Rvbt0B3ByD41gs7We8OnHUzqD7g90AE3byIeD7Ewn0QcdzAy0EIuF/ciU8cPPvEoPqA34MRdPP0Cebip4+Yi3fvJBe/hOjcLfaPB9kOYbSOrE1ZljIlJ4RI3lslVExcsXYyI0qOVUUX2syp5It2UsQcUvEcs3+HTKR/Y/sW6O4QBN96aSfr3aGzbgbVB/weiqCblxHPh1i4DyOOG3g5DAH3yzvxicNnnxhUH/B7OMbrECaYi585Yi7es5Nc/Aqic7fnss+ZNKJNnS7Gt30pt0m3c5igfORtykJ2XnPVvmUNf7Hw1i9RZ629UzzCbf0Zs39HTKR/Y/sW6O4IBN96ZSfr3ZGzbgbVB/weiaCbVxHPh1i4jyKOG3g5CgH3qzvxiaNnnxhUH/B7NIJuwgRzcRgxF8dOcvFriM5dXHb/knJSu0YQr1wLHVUS3GnZDm50m0HlQlVGF1+tz8Vnbtrj4dMotczB+mAx+3fMRPo3tm+B7o5B8K3XdrLeHTvrZlB9wO+xCLp5HfF8iIX7OOK4gZfjEHC/vhOfOH72iUH1Ab/HY7w+d4K5uIyYi2snufgNROdusX8iq1BLtsEyV7RvYJ3K1hjhRRWpbTuTzk43dIYzq7L2IcuqefHS+NAej9m/EybSv7F9C3R3AoJvvbGT9e7EWTeD6gN+T0TQzZuI50Ms3CcRxw28nISA+82d+MRbZp8YVB/w+xYE3Txngrn4OSPm4n06ycVvJTp3i/3jiZXI2i5TJe+MKcLylEXbaFZuq22nOKqGCPc4Meei18XKnFLbmHqRGuxgMPt38kT6N7Zvge5ORvCtt3Wy3r191s2g+oDftyPo5h3E8yEW7ncSxw28vBMB97s68YlTZp8YVB/wewrG+9ZMMBc/b8RcvF8nufjdROdusX/CWNamqagqZLDZOhMyb/+MUssgqotOCOOTjdqFaFm2cNuS4qbBlyor1PejeM9E+je2b4Hu3oPgW+/tZL1736ybQfUBv+9D0M37iedDLNynEscNvJyKgPsDnfjEabNPDKoP+D0NQTcvmGAufsGIufiATnLxB4nO3bL+qdI2oxk2myxy7lybN85MKEInppQNCV7WmpPJRqRabC1JZOu9zLUd7giB2b/TJ9K/sX0LdHc6gm99qJP17oxZN4PqA37PQNDNh4nnQyzcZxLHDbyciYD7I534xFmzTwyqD/g9C0E3L5pgLn7RiLn4oE5y8UeJzt2y/uUqpdQ5cFmrMtVo5nX1VmeurXNGKB5KSrVKV7OPMXjRmlKdNz7bwjxm/86eSP/G9i3Q3dkIvvWxTta7c2bdDKoP+D0HQTcfJ54PsXCfSxw38HIuAu5PdOITn5x9YlB9wO8nEXTzkgnm4peMmIsP6SQXf4ro3B2y7L7+WqsR0QsnSmI68hpU24f6YNo2tMTiQzKyAZZZRM6KUtEXVgv3pR3TlILZv/Mm0r+xfQt0dx6Cb326k/XuM7NuBtUH/H4GQTefJZ4PsXCfTxw38HI+Au7PdeITF8w+Mag+4PcCBN28bIK5+GUj5uLDOsnFnyc6d8v650oqQrk2San9P1umjfdRp8xs8p61YxlrBY8hah+NtjFy6UrDXIoxXqG+f/GFE+nf2L4FursQwbe+0Ml6d9Gsm0H1Ab8XIejmi8TzIRbui4njBl4uRsD9pU584pLZJwbVB/xegqCbV0wwF79ixFx8RCe5+MtE526xfyLxEB3P0TAbgzU5Vstrw6RFctrEyp1kSnnHk4wm85olj7xtV5l1VVvUz7u7dCL9G9u3QHeXIvjWVzpZ774662ZQfcDvVxF08zXi+RAL92XEcQMvlyHg/nonPvGN2ScG1Qf8fgNBN6+aYC5+1Yi5+KhOcvE3ic7dsv7xXEx1zpn2vyI1j1WlELLwMmZnSvtNqUa6dkTDdYqOea1EYe1hMbZvHWb/Lp9I/8b2LdDd5Qi+9a1O1rsrZt0Mqg/4vQJBN98mng+xcF9JHDfwciUC7u904hNXzT4xqD7g9yoE3bxmgrn4NSPm4mM6ycXfJTp3i/0TMmcXtTU1CGek5M6obGSytmYnajA8B8utltIJ+GhJJwy3JWatQixRob5/8dUT6d/YvgW6uxrBt77XyXr3/Vk3g+oDfr+PoJsfEM+HWLivIY4beLkGAfcPO/GJH80+Mag+4PdHCLp53QRz8etGzMXHdZKLf0x07hb7x42Hz80pmusoUikut4MZ79upjOXCStMeHmz1okapkiyyailyaX8qQ0htU4rZv2sn0r+xfQt0dy2Cb/2kk/Xup7NuBtUH/P4UQTc/I54PsXBfRxw38HIdAu6fd+IT188+Mag+4Pd6BN28YYK5+A0j5uITOsnFvyA6d8v6V1J1DZl3BeYpeB/aDDKXheWV1+BF0Yy7xENy3metVU481yB1KpEF1P7dMJH+je1boLsbEHzrl52sd7+adTOoPuD3Vwi6+TXxfIiF+0biuIGXGxFw/6YTn7hp9olB9QG/NyHo5k0TzMVvGjEXn9RJLv4t0blb1r+cWDbFmlBjkNbmbLwsWSVlg6q+lmKDa5vUXHWuRtTMTBXVWXgtQOEJ9f7imyfSv7F9C3R3M4Jv/a6T9e73s24G1Qf8/h5BN38gng+xcN9CHDfwcgsC7j924hN/mn1iUH3A758QdPPWCebit46Yi0/uJBf/mejcLetfdpk5bbmWPhnXRi+HLIIx0gnPsxTSq3aKY0PblPpgYxElcZWdl8zFaFDfp+3WifRvbN8C3d2K4Ft/6WS9++usm0H1Ab9/RdDN34jnQyzctxHHDbzchoD77534xNIqs08MqQ/4hd6NrZt3TDAXv2PEXPzOTnLxHYjO3WL/uM3csmIl3LpfvBDJS1UbopBlEq46XSpXUfBkpVbtbwvv4DYna7xtO1aF2b8VJtK/sX0LdLcCgm/dcZU+5m7FWTeD6gN+V0TQzZ1G1k0vuFcijht4WQkB98qd+MQqs08Mqg/4XQVBN++eYC5+94i5+D2d5OJVic7dsv75ko1kWbF2GgOfth6karA114mnKI1rZzZMJ5VLFiZX6YwWWXgWhantbKdi9m+1ifRvbN8C3a2G4Furd7LerTHrZlB9wO8aCLpZk3g+xMK9FnHcwMtaCLjX7sQn1pl9YlB9wO86CLp5/wRz8ftHzMWndpKL70x07hb7J6KWjnslM9yzJGNm2gdllY1W1MS5qcz7pAxjKifHec5RKVbh43QaZo76OdB3mUj/xvYt0N1dEHzrrp2sd+vOuhlUH/C7LoJu7kY8H2LhXo84buBlPQTcd+/EJ9affWJQfcDv+gi6+eAEc/EHR8zFp3eSi+9BdO5OX/6+4W0HWryzxRudYAOamNCieJujizVaZ4zLbWfqU64mWZg51qY1Zi2ijJj922Ai/Rvbt0B3GyD41j07We82nHUzqD7gd0ME3dyLeD7Ewn1v4riBl3sj4L5PJz6x0ewTg+oDfjdC0M2HJ5iLPzxiLj6zk1x8X6Jzt9g/HrhLzpvKhUpZOcFrLMyFZBxrMyeNSFxLpQz3qVRmhbOqKmk9vHdMFRKzfxtPpH9j+xbobmME37pfJ+vdJrNuBtUH/G6CoJv7E8+HWLg3JY4beNkUAfcDOvGJzWafGFQf8LsZgm4+OsFc/NERc/HZneTiBxKdu7OXvW9422yGykooItW2J60mSsVizQpu8udJNfA21lqNN1zC2794K0Rpj9Ft7lD796CJ9G9s3wLdPQjBtx7cyXq3+aybQfUBv5sj6OYhxPMhFu4tiOMGXrZAwP3QTnyCzT4xqD7glyHo5uMTzMUfHzEXn9tJLuZE526xfzzXrJ21wpSklNBGl6hsbWc1UlnFjFTRaCMyj4ZxL7yyvE2lM5aFoBhHfT8KMZH+je1boDuB4Fuyk/VOzboZVB/wqxB0o4nnQyzchjhu4MUg4Lad+ISbfWJQfcCvQ9DNpyaYiz81Yi4+r5Nc7InO3WL/uLLBMxVT5jbIakyJ2cJHTnJhvWa2PbwYJpwSgSnbBq9mzn2WvOQqvUDNxVtOpH9j+xbobksE33pYJ+vdVrNuBtUH/G6FoJuHE8+HWLgfQRw38PIIBNyP7MQnHjX7xKD6bucXQTefnWAu/uyIufj8TnLxo4nO3fL+GcG5UcXFNnjKGt7wFhFCzD7wYGxJienqhYkl6RhDKtFqoQw3pf09g9m/rSfSv7F9C3S3NYJvPaaT9W6bWTeD6gN+t0HQzWOJ50Ms3NsSxw28bIuA+3Gd+MR2s08Mqg/43Q5BN5+fYC7+/Ii5+MJOcvHjic7dYv+EYzWl4nkbLRZNA1OKLCY46UKMiVfbzm1UUU7LKERmxgZtqi6eOeUbbsz+bT+R/o3tW6C77RF86wmdrHc7zLoZVB/wuwOCbp5IPB9i4d6ROG7gZUcE3E/qxCd2mn1iUH3A704IuvniBHPxF0fMxRd3koufTHTuFvsnsvKZyRBNtIorr4vKNsXS5i+YVFllJpTg2qgJl7nM2lYTWHtUcsZlFjH7t/NE+je2b4Hudkbwrad0st7tMutmUH3A7y4Iunkq8XyIhXtX4riBl10RcD+tE5/YbfaJQfUBv7sh6ObLE8zFXx4xF1/aSS5+OtG5W+yfCNpHUxRnTovsjTFcWc9t22/yUKWryrpoDZMlyqKqkG3j6o2U2QmTckG9Xrz7RPo3tm+B7nZH8K1ndLLe7THrZlB9wO8eCLp5JvF8iIV7T+K4gZc9EXA/qxOf2Gv2iUH1Ab97IejmaxPMxV8bMRdf1kkuDkTn7rJl749orZM1+FptlCa34xm4QakYnWpybbhYtCzD5+lEzUPUVumia+E5SZ195Jj9ixPp39i+BbqLCL6VOlnv8qybQfUBvxlBN4V4PsTCXYnjBl4qAu5nd+ITe88+Mag+4HdvBN18c4K5+Jsj5uLLO8nFzyE6d5cvu3/JZF5sYdLXcPs3MbtajC+8TV8K2XDjZUoNWAOvnLLc8xiKqFUqFQVm//aZSP/G9i3Q3T4IvvXcTta7fWfdDKoP+N0XQTfPI54PsXDvRxw38LIfAu7nd+IT+88+Mag+4Hd/BN18e4K5+Nsj5uIrO8nFLyA6d8v6V0M7osmxuMJVcUlL1gD4EGo7kHE+hxhlTkyYWkuKTPkss4lt4FJrB7MWs38HTKR/Y/sW6O4ABN96YSfr3YGzbgbVB/weiKCbFxHPh1i4DyKOG3g5CAH3izvxiYNnnxhUH/B7MIJuvjvBXPzdEXPx1Z3k4pcQnbtl/StthrSRugbdUDEnfGqgpEhKGh5rsCXXXBWLTHOV2iF1lsFK6VpPKveonwN9yET6N7Zvge4OQfCtl3ay3h0662ZQfcDvoQi6eRnxfIiF+zDiuIGXwxBwv7wTnzh89olB9QG/hyPo5gcTzMU/GDEXX9NJLn4F0blb7J+QkZVgeXQxZpmiEfC616KFrjq5KHWKtWQnGOxQhVTw2lhltE65Wt4OdzD7d8RE+je2b4HujkDwrVd2st4dOetmUH3A75EIunkV8XyIhfso4riBl6MQcL+6E584evaJQfUBv0cj6ObHE8zFPx4xF1/bSS5+DdG5u3bZ611TydqKHGsWxihtPJOspio9Z7zBEtX6NnuxyHYsw5XzqsaabIMf2gxWzP4dM5H+je1boLtjEHzrtZ2sd8fOuhlUH/B7LIJuXkc8H2LhPo44buDlOATcr+/EJ46ffWJQfcDv8Qi6+dkEc/HPRszF13WSi99AdO6W9U8maaJULHORQxVKiFpi5jooLXiV7XBGe6ZtEqHW3KCbZGwNsm1VU2rbU8z+nTCR/o3tW6C7ExB8642drHcnzroZVB/weyKCbt5EPB9i4T6JOG7g5SQE3G/uxCfeMvvEoPqA37cg6OYXE8zFvxgxF9/QSS5+K9G5W+wft9moBFtQ4aXxifk2Xlr4ZLUU0bUxdPDi12py9hlu8zdMxuBMil7o1hzM/p08kf6N7Vugu5MRfOttnax3b591M6g+4PftCLp5B/F8iIX7ncRxAy/vRMD9rk584pTZJwbVB/yegqCbX08wF/96xFx8Yye5+N1E525Z/7xmmskGRHFpikpWRtVOaEJkzMVqhA5WJs1Dm8ZibfU+GWZSsO18x8iMmovfM5H+je1boLv3IPjWeztZ794362ZQfcDv+xB0837i+RAL96nEcQMvpyLg/kAnPnHa7BOD6gN+T0PQzW8nmIt/O2IuvrmTXPxBonO32D/OUmA1i+B1TNw724ZJWl21MdwJZWRhyYsSuBC5GuV05UkVHbw1PkqRMPt3+kT6N7Zvge5OR/CtD3Wy3p0x62ZQfcDvGQi6+TDxfIiF+0ziuIGXMxFwf6QTnzhr9olB9QG/ZyHo5g8TzMV/GDEX39JJLv4o0blb7J/w1cjkpS61CKGKkDrrqBpWp61r4xWFbntUH6QSWQWWfdumeleq1TZHg/p5d2dPpH9j+xbo7mwE3/pYJ+vdObNuBtUH/J6DoJuPE8+HWLjPJY4beDkXAfcnOvGJT84+Mag+4PeTCLr58wRz8Z9HzMW3dpKLP0V07hb7xwsXriErtba5kjxy62Ly2qbEkuKBZyukZdrC/UqmZuZZiTIZaUz0pWrM/p03kf6N7Vugu/MQfOvTnax3n5l1M6g+4PczCLr5LPF8iIX7fOK4gZfzEXB/rhOfuGD2iUH1Ab8XIOjmb53k4tVHfK41RuzfbX30T4y5r/jbiPuKv3fSvzG95rYR+7e0Vh++//kRfX9EzfBe+nfhRPo39roJursQYd38Qid566JZN4PqA34vQtDNF4nvT7BwX0wcN/ByMQLuL3XiE5fMPjGoPuD3EgTd3Om/lEvYf/Y15r5MfXP18fq3Uh/9E68lui9buZP+jbmvXZy5/7R/q3QyvyPOCV95xP6t2sm+7MsjrpsjaoYv9k8UUWKEq5jCm2hkdq7AfbCVeWtC9u3iJs+qxHbAL3jOuT0a3izBFstCO+5HPW+8dCL9Gzt3gO4uRcgdX+kkr3511s2g+oDfryLo5mvE93dYuC8jjht4uQwB99c78YlvzD4xqD7g9xsIull7gvuKtUfMxet0kou/uQrOrLD/7Isv9k/wWBPXKurILM9CZGY408ZIraVjvDrtEq9CciZYVEl4Hqzw2QjHs1Son5d6+UT6N7Zvge4uR/Ctb3Wy3l0x62ZQfcDvFQi6+TbxfIiF+0riuIGXKxFwf6cTn7hq9olB9QG/VyHo5q4TzMV3HTEXr9tJLv4u0blb7B8XJtUgtYisCMu4UiJKU1gSNTknnE01y1hLSg2pCDWxIot12ZUcVcgOs39XT6R/Y/sW6O5qBN/6Xifr3fdn3QyqD/j9PoJufkA8H2LhvoY4buDlGgTcP+zEJ340+8Sg+oDfHyHo5u4TzMV3HzEXr99JLv4x0blb1j/JfLbM2BCNzoUH72sRsirtMotJVu6S9tEYJUpVrg2esb5UblM0XjjU9/m8diL9G9u3QHfXIvjWTzpZ734662ZQfcDvTxF08zPi+RAL93XEcQMv1yHg/nknPnH97BOD6gN+r0fQzT0nmIvvOWIu3rCTXPwLonO32D/uVVLGS8W8N8YbFotzmstUixS+bUe50NVy6V2wThSlvJU1tvlT1ruIe734hon0b2zfAt3dgOBbv+xkvfvVrJtB9QG/v0LQza+J50Ms3DcSxw283IiA+zed+MRNs08Mqg/4vQlBN/eZYC6+z4i5eKNOcvFvic7dsv7p4JQ3TsWkXUosm+Kr5D6qHIowOXLLrWwnNYa1/5y9dUXxzHywOpj2OMz+3TyR/o3tW6C7mxF863edrHe/n3UzqD7g9/cIuvkD8XyIhfsW4riBl1sQcP+xE5/40+wTg+oDfv+EoJv7TTAX32/EXLxJJ7n4z0TnbrF/vG0qYcTaFlRp2b4R1bOsOLwGtkjJoghOOBODCm3YUmib0ZhT9VJoqSLu+1HcOpH+je1boLtbEXzrL52sd3+ddTOoPuD3rwi6+RvxfIiF+zbiuIGX2xBw/70Tn1hadfaJIfUBv9C7sXXzgAnm4geMmIs36yQX34Ho3C3rn5UmGZay9DVzo3xWrmFU1QdTko9t1JyvUeTCgsy2lBCLkq0PURtma8Ds3woT6d/YvgW6WwHBt+64ah9zt+Ksm0H1Ab8rIujmTiPrphfcKxHHDbyshIB75U58YpXZJwbVB/yugqCbB08wFz94xFy8eSe5eFWic7fYP9GOW7zlwWeReIYzGqskvJ61Gq68iDxmmZTRTiVmTbAmKZlkyjxYZTUXmP1bbSL9G9u3QHerIfjW6p2sd2vMuhlUH/C7BoJu1iSeD7Fwr0UcN/CyFgLutTvxiXVmnxhUH/C7DoJuHjrBXPzQEXMx6yQX35no3C3rX5DSysx1DSanIgSvTgphEhPttKa6UIJONZkcVPJVecdDDm0Y236UVW0KZv/uMpH+je1boLu7IPjWXTtZ79addTOoPuB3XQTd3I14PsTCvR5x3MDLegi4796JT6w/+8Sg+oDf9RF0IyeYi+WIuVh1kovvQXTuFvsnom1MuyJiVYWx9htRco5tR6q4Z9nKJJzPqTVCR1mNKm1CXcystMFMxqJeL95gIv0b27dAdxsg+NY9O1nvNpx1M6g+4HdDBN3ci3g+xMJ9b+K4gZd7I+C+Tyc+sdHsE4PqA343QtCNnWAutiPmYtdJLr4v0blb1r8oVKnKtHMXXkr2MmdpjFSi+hRUKTFa5ZML7TiHaZsc41lLl2xixsDd/pj923gi/Rvbt0B3GyP41v06We82mXUzqD7gdxME3dyfeD7Ewr0pcdzAy6YYr5/qxCc2m31iUH3A72YIunnYBHPxw0bMxVt1kosfSHTulvVPZ15YSNqa9pvkuIpGcM2NlD4UHoTnyeYqTdQ1m1RZVEUmn7LQRTLc68UPmkj/xvYt0N2DMF4X0cl6t/msm0H1Ab+bI+jmIcTzIRbuLYjjBl62wLhPtBOfYLNPDKoP+GUIunnkBHPxI0fMxY/qJBdzonO32D9heaqxOle8Vaoh9KbYIrJxVrfdZxtLVoxoZzuMt+mUungdbCpCehaTZhWzf2Ii/Rvbt0B3AuP+r07WOzXrZlB9wK9C0I0mng+xcBviuIEXg3Ee3olPuNknBtUH/DoE3Txmgrn4MSPm4m06ycWe6Nxts+zzdIxkvvLMLctW8RB5Kp4l6a1t42ZrtCmXZF2S1jkRvQtta2q8NonLXFBz8ZYT6d/YvgW62xLjnKuT9W6rWTeD6gN+t0LQzcOJ50Ms3I8gjht4eQTGdb9OfOJRs08Mqu92fhF087gJ5uLHjZiLt+skFz+a6Nwt9o8Lmzjnph3U6MRkstVkJxW32SUepWOuelEKN16ooBXzKtb2Dyt48UVV1M/12Hoi/Rvbt0B3W2Ps5ztZ77aZdTOoPuB3GwTdPJZ4PsTCvS1x3MDLthj5phOf2G72iUH1Ab/bIejmCRPMxU8YMRfv0EkufjzRuVvsH4+1WseULcXYLF2brZpTG7Dqg4iBtTmUyvmQsjRK6MpDEbef2AjvhMHNxdtPpH9j+xbobnsM3+pkvdth1s2g+oDfHRB080Ti+RAL947EcQMvOyLgflInPrHT7BOD6gN+d8LQzQRz8ZNGzMU7dZKLn0x07pb1zySbk40xFMN1TZU7b6qILkebvUhM58RL4MlxqYrP0dSsnTNWJC2LD5j923ki/Rvbt0B3OyP41lM6We92mXUzqD7gdxcE3TyVeD7Ewr0rcdzAy64IuJ/WiU/sNvvEoPqA390w1pcJ5uKnjJiLd+kkFz+d6NztsuycJrf9aIqBW12qNTnWlHyyTnthYpRe+eBsSVY3rELrtku1wajoeSptWFGvF+8+kf6N7Vugu90RfOsZnax3e8y6GVQf8LsHgm6eSTwfYuHekzhu4GVPBNzP6sQn9pp9YlB9wO9eGPupCebip42Yi3frJBcHonO327L3Dc8q5eSNKDIHI1KU7ZtqkxIu+Miy5i7W21/iaqqrqbSpC20+fajRtOMczP7FifRvbN8C3UUE30qdrHd51s2g+oDfjKCbQjwfYuGuxHEDLxUB97M78Ym9Z58YVB/wuzfGdZcJ5uJnjJiL9+gkFz+H6Nwt9k+okrN0yta2vSxKJZWS9EwoU6RswNof5Ja0mGSZpcyiakc5tsbMU4i1aIfZv30m0r+xfQt0tw+Cbz23k/Vu31k3g+oDfvdF0M3ziOdDLNz7EccNvOyHgPv5nfjE/rNPDKoP+N0f45xhgrn4WSPm4r06ycUvIDp3i/1rxy3MNChJaMNj1FYWlaoS2mcZWWTFl5CiUtZqnoyI1mZ4Y8QC7x5uM0e9j+KAifRvbN8C3R2A4Fsv7GS9O3DWzaD6gN8DEXTzIuL5EAv3QcRxAy8HIeB+cSc+cfDsE4PqA34PxjiPnGAuTiPm4txJLn4J0blb7B93DO7PrywrXX0pbasZuNSxZuml8EUqJ20xUmqjk+SqRt/2ptHnaKVrg4rZv0Mm0r+xfQt0dwiCb720k/Xu0Fk3g+oDfg9F0M3LiOdDLNyHEccNvByGgPvlnfjE4bNPDKoP+D0c4/6bCebiZ4+Yi/fuJBe/gujcLfaPG1FrcFYJLl07qdHccONidQbeLDzykHlxUUsdktLwUTo1RiESl9UnHXzB7N8RE+nf2L4FujsCwbde2cl6d+Ssm0H1Ab9HIujmVcTzIRbuo4jjBl6OQsD96k584ujZJwbVB/wejXGf3gRz8XNHzMX7dpKLX0N07pb1z7ZNaFANowmpwRUpOGGErIkVl31o21JvgrLBMS5L8An2odql9lei5dpj9u+YifRvbN8C3R2D4Fuv7WS9O3bWzaD6gN9jEXTzOuL5EAv3ccRxAy/HIeB+fSc+cfzsE4PqA36Px7gvfYK5+Pkj5uL9O8nFbyA6d8v6F5QPVbSdKOeR6ZiZCMa3QYs8hqyj4JYpZkMOgnMlKjNFFc58Ls4FHg1m/06YSP/G9i3Q3QkIvvXGTta7E2fdDKoP+D0RQTdvIp4PsXCfRBw38HISAu43d+ITb5l9YlB9wO9bMF6/MsFc/MIRc/GBneTitxKduwOXvT9ikqrAWx22cUvtSxovfHFVhTZhzFpeuJa1WuuVzEHrpGpyhmlp285UBsz+nTyR/o3tW6C7kxF8622drHdvn3UzqD7g9+0IunkH8XyIhfudxHEDL+9EwP2uTnzilNknBtUH/J6C8XrNCebiF4+Yiw/uJBe/m+jcLe+fy0W3I5qoimy1y4avpqJdbgc1uihZswilZmdiSFKHWHSD285p2mNyTKjv0/aeifRvbN8C3b0Hwbfe28l6975ZN4PqA37fh6Cb9xPPh1i4TyWOG3g5FQH3BzrxidNmnxhUH/B7GsbruieYi186Yi4+tJNc/EGic7esf7Dv9M5FzbLn2koVqxTeZCeZtrUW0/agrDrvbFHa21iKzVLKlIUKzqC+T9vpE+nf2L4Fujsdwbc+1Ml6d8asm0H1Ab9nIOjmw8TzIRbuM4njBl7ORMD9kU584qzZJwbVB/yehfE+JhPMxS8fMRcf3kku/ijRuTt82fuGcy6MlF6YVJNhwtUgas2+Ms8iLxo+V4cFZ7Pl3EndDm/ajGZlmVJecIvZv7Mn0r+xfQt0dzaCb32sk/XunFk3g+oDfs9B0M3HiedDLNznEscNvJyLgPsTnfjEJ2efGFQf8PtJjPc7mmAufuWIufjITnLxp4jO3bL+ZW3a/tM7UWWu0gVZua/RcZUk47Iq7mNgJTrFZBQ2sXZ8Y3UytfBUlUG9j+K8ifRvbN8C3Z2H4Fuf7mS9+8ysm0H1Ab+fQdDNZ4nnQyzc5xPHDbycj4D7c534xAWzTwyqD/i9AEE3r55gLn71iLn46E5y8eeJzt1i/3hlvFTHrJHJ66plUlLxhtvL7I2VoZQq2s608hC49zYba6PWNnrjRXEBs38XTqR/Y/sW6O5CBN/6Qifr3UWzbgbVB/xehKCbLxLPh1i4LyaOG3i5GAH3lzrxiUtmnxhUH/B7CYJuXjvBXPzaEXPxsZ3k4i8TnbvF/nGmkxbattHjWthiWGTS8NQeZ3XUwfoscjJO8OwCF9plz0zJqg2oLTaifq7HpRPp39i+Bbq7FMG3vtLJevfVWTeD6gN+v4qgm68Rz4dYuC8jjht4uQwB99c78YlvzD4xqD7g9xsIunn9BHPx60fMxcd3kou/SXTulvVP5qiZDixJkWIbuMC8l84nwR1rZzFOOmFrVDz7WrJT2TlrTK5KJSOZRf1cj8sn0r+xfQt0dzmCb32rk/Xuilk3g+oDfq9A0M23iedDLNxXEscNvFyJgPs7nfjEVbNPDKoP+L0KQTdvnGAufuOIufjETnLxd4nO3YnL3h/RiGKlq9LlaBJsP1X2VljhlRI8Za9DDUJVZRlLXAoZopNJBmZCKlJg9u/qifRvbN8C3V2N4Fvf62S9+/6sm0H1Ab/fR9DND4jnQyzc1xDHDbxcg4D7h534xI9mnxhUH/D7IwTdvHmCufjNI+bit3SSi39MdO6W9a8U45Is0iXuFZPSe5VYVtnGXKSOtU1d+5cQwevqua5OJB1kZEqImD3q/cXXTqR/Y/sW6O5aBN/6SSfr3U9n3QyqD/j9KYJufkY8H2Lhvo44buDlOgTcP+/EJ66ffWJQfcDv9Qi6edsEc/HbRszFb+8kF/+C6Nwt9k8UeKuXNmSCJWWry6KyEHwxivtqvTAhpqy90cwp4UVoj87ZOsasLcYz1OvFN0ykf2P7FujuBgTf+mUn692vZt0Mqg/4/RWCbn5NPB9i4b6ROG7g5UYE3L/pxCdumn1iUH3A700IunnXBHPxu0bMxad0kot/S3TuFvt3+zsgZsmzCNLxNmiFBS8UT8oI4YMQNXvphGrYVDujYaXNY2a1RO2MNqFi9u/mifRvbN8C3d2M4Fu/62S9+/2sm0H1Ab+/R9DNH4jnQyzctxDHDbzcgoD7j534xJ9mnxhUH/D7JwTdvHeCufi9I+bi93WSi/9MdO6W9S8G6SvjbcxCNMGmagT3WlgtaspFOWNttlWKXJUt7SSnhFSV1yrpUg3u/cW3TqR/Y/sW6O5WBN/6Syfr3V9n3QyqD/j9K4Ju/kY8H2Lhvo04buDlNgTcf+/EJ5ZWm31iSH3AL/Ru9M8Pn2Au/sCIufi0TnLxHYjO3WL/hE+MRaZd4nD60uYv5sRM5MXKWnXbelYtc/WmOmXajtUlpq3InNcUqnMRs38rTKR/Y/sW6G4FBN+642p9zN2Ks24G1Qf8roigmzuNrJtecK9EHDfwshIC7pU78YlVZp8YVB/wuwqCbj40wVz8oRFz8Rmd5OJVic7dsv5FIxhzvsFiwSRjvaqp8iQij7yNnQyWy+SZDi4GXlsndLWa8Vp40Cyift7dahPp39i+BbpbDcG3Vu9kvVtj1s2g+oDfNRB0sybxfIiFey3iuIGXtRBwr92JT6wz+8Sg+oDfdRB085EJ5uKPjJiLz+okF9+Z6Nwt9k/EZKRvQ9bwWMnbKU0WyVTpeVbKuyK9SNHqklPMOqnEahtAYXI7uDHwRuKY/bvLRPo3tm+B7u6C4Ft37WS9W3fWzaD6gN91EXRzN+L5EAv3esRxAy/rIeC+eyc+sf7sE4PqA37XR9DNxyaYiz82Yi4+p5NcfA+ic7fYPxGcr9KVhpQleJUrF5a1wxpjc/uPbfPJlWYyt6MZa2KVybYdKuO5nefI4JTSmP3bYCL9G9u3QHcbIPjWPTtZ7zacdTOoPuB3QwTd3It4PsTCfW/iuIGXeyPgvk8nPrHR7BOD6gN+N0LQzScmmIs/MWIu/mQnufi+ROdusX+8HbqUXGwpJaoCb/EiXRu6GpLJQrOgFdO6/WHInBXjowymgWTWpOCsM6j3UWw8kf6N7Vugu40RfOt+nax3m8y6GVQf8LsJgm7uTzwfYuHelDhu4GVTBNwP6MQnNpt9YlB9wO9mCLr59ARz8adHzMWf6SQXP5Do3C3rX2oHLvDmh7GNlghWSc51LFoKn7XSLgvvmGCuneBUn0NS3LTjGmE0rz4WETH796CJ9G9s3wLdPQjBtx7cyXq3+aybQfUBv5sj6OYhxPMhFu4tiOMGXrZAwP3QTnyCzT4xqD7glyHo5nMTzMWfGzEXX9BJLuZE526xfw0Dk0VkJ1XhsNUsUiYfohUmyGJ1ziyH7GMtgQclhbHc+/YwoaRvSFFzsZhI/8b2LdCdQPAt2cl6p2bdDKoP+FUIutHE8yEWbkMcN/BiEHDbTnzCzT4xqD7g1yHo5gsTzMVfGDEXX9RJLvZE5+6iZff1aysc5ym0wQuac9YOZGzDrFLJ0ogSS802ZV64a5tWa3zxSuoGttSkC+r9xVtOpH9j+xbobksE33pYJ+vdVrNuBtUH/G6FoJuHE8+HWLgfQRw38PIIBNyP7MQnHjX7xKD6bucXQTdfmmAu/tKIufiSTnLxo4nO3SXL718Sbei09b4WUYITydjEgsvMGRl1KYmVdiRj266V+7Y9VUy0b5iLWlYTFWb/tp5I/8b2LdDd1gi+9ZhO1rttZt0Mqg/43QZBN48lng+xcG9LHDfwsi0C7sd14hPbzT4xqD7gdzsE3Xxlgrn4KyPm4q92kosfT3TulvVPMVu0it6Ehkwmw3wN0nobhZDJyiwMC9LokLWLQjvPgzaGCSuYNzGjXi/efiL9G9u3QHfbI/jWEzpZ73aYdTOoPuB3BwTdPJF4PsTCvSNx3MDLjgi4n9SJT+w0+8Sg+oDfnRB08/UJ5uKvj5iLv9FJLn4y0blb7B8Psh3CaB1Zm7IsZUpOCJG8t0qomLhi7WRGlByrii60mVPJF+2kiDmk4jlm/3aeSP/G9i3Q3c4IvvWUTta7XWbdDKoP+N0FQTdPJZ4PsXDvShw38LIrAu6ndeITu80+Mag+4Hc3BN18a4K5+Fsj5uIrOsnFTyc6d1cs+5xJI9rU6WJ825dym3Q7hwnKR96mLGTnNVftW9bwFwtv/RJ11to7xSPc1p8x+7f7RPo3tm+B7nZH8K1ndLLe7THrZlB9wO8eCLp5JvF8iIV7T+K4gZc9EXA/qxOf2Gv2iUH1Ab97IejmOxPMxd8ZMRdf1UkuDkTn7qpl9y8pJ7VjHD5EUgsdVRLcadkObnSbQeVCVUYXX63PxWdu2uPh0yi1zMH6YDH7FyfSv7F9C3QXEXwrdbLe5Vk3g+oDfjOCbgrxfIiFuxLHDbxUBNzP7sQn9p59YlB9wO/eCLr53gRz8fdGzMXf7yQXP4fo3C32T2QVask2WOaK9g2sU9kaI7yoIrVtZ9LZ6YbOcGZV1j5kWTUvXhof2uMx+7fPRPo3tm+B7vZB8K3ndrLe7TvrZlB9wO++CLp5HvF8iIV7P+K4gZf9EHA/vxOf2H/2iUH1Ab/7I+jmhxPMxT8cMRf/qJNc/AKic7fYP55YiaztMlXyzpgiLE9ZtI1m5bbadoqjaohwjxNzLnpdrMwptY2pF6nBDgazfwdMpH9j+xbo7gAE33phJ+vdgbNuBtUH/B6IoJsXEc+HWLgPIo4beDkIAfeLO/GJg2efGFQf8Hswgm5+MsFc/JMRc/FPO8nFLyE6d4v9E8ayNk1FVSGDzdaZkHn7Z5RaBlFddEIYn2zULkTLsoXblhQ3Db5UWaG+H8UhE+nf2L4FujsEwbde2sl6d+ism0H1Ab+HIujmZcTzIRbuw4jjBl4OQ8D98k584vDZJwbVB/wejqCbn08wF/98xFx8fSe5+BVE525Z/1Rpm9EMm00WOXeuzRtnJhShE1PKhgQva83JZCNSLbaWJLL1XubaDneEwOzfERPp39i+Bbo7AsG3XtnJenfkrJtB9QG/RyLo5lXE8yEW7qOI4wZejkLA/epOfOLo2ScG1Qf8Ho2gm19OMBf/csRc/KtOcvFriM7dsv7lKqXUOXBZqzLVaOZ19VZnrq1zRigeSkq1SlezjzF40ZpSnTc+28I8Zv+OmUj/xvYt0N0xCL712k7Wu2Nn3QyqD/g9FkE3ryOeD7FwH0ccN/ByHALu13fiE8fPPjGoPuD3eATd/GaCufg3I+bimzrJxW8gOnc3Lbuvv9ZqRPTCiZKYjrwG1fahPpi2DS2x+JCMbIBlFpGzolT0hdXCfWnHNKVg9u+EifRvbN8C3Z2A4Ftv7GS9O3HWzaD6gN8TEXTzJuL5EAv3ScRxAy8nIeB+cyc+8ZbZJwbVB/y+BUE3v5tgLv7diLn4953k4rcSnbtl/XMlFaFcm6TU/p8t08b7qFNmNnnP2rGMtYLHELWPRtsYuXSlYS7FGK9Q37/45In0b2zfAt2djOBbb+tkvXv7rJtB9QG/b0fQzTuI50Ms3O8kjht4eScC7nd14hOnzD4xqD7g9xQE3fxxgrn4jyPm4j91kovfTXTuFvsnEg/R8RwNszFYk2O1vDZMWiSnTazcSaaUdzzJaDKvWfLI23aVWVe1Rf28u/dMpH9j+xbo7j0IvvXeTta79826GVQf8Ps+BN28n3g+xMJ9KnHcwMupCLg/0IlPnDb7xKD6gN/TEHTzlwnm4r+MmIv/2kku/iDRuVvWP56Lqc450/5XpOaxqhRCFl7G7ExpvynVSNeOaLhO0TGvlSisPSzG9q3D7N/pE+nf2L4Fujsdwbc+1Ml6d8asm0H1Ab9nIOjmw8TzIRbuM4njBl7ORMD9kU584qzZJwbVB/yehaCbv08wF/99xFy8tHYfc/dRonO32D8hc3ZRW1ODcEZK7ozKRiZra3aiBsNzsNxqKZ2Aj5Z0wnBbYtYqxBIV6vsXnz2R/o3tW6C7sxF862OdrHfnzLoZVB/wew6Cbj5OPB9i4T6XOG7g5VwE3J/oxCc+OfvEoPqA308i6OaO/6Vcx/6zr1Fz8SLm/7R/K3aSiz9FdO4W+8eNh8/NKZrrKFIpLreDGe/bqYzlwkrTHh5s9aJGqZIssmopcml/KkNIbVOK2b/zJtK/sX0LdHcegm99upP17jOzbgbVB/x+BkE3nyWeD7Fwn08cN/ByPgLuz3XiExfMPjGoPuD3AgTdrDzBXLzyiLl4lU5y8eeJzt2y/pVUXUPmXYF5Ct6HNoPMZWF55TV4UTTjLvGQnPdZa5UTzzVInUpkAbV/F06kf2P7FujuQgTf+kIn691Fs24G1Qf8XoSgmy8Sz4dYuC8mjht4uRgB95c68YlLZp8YVB/wewmCblafYC5efcRcvEYnufjLROduWf9yYtkUa0KNQVqbs/GyZJWUDar6WooNrm1Sc9W5GlEzM1VUZ+G1AIUn1PuLL51I/8b2LdDdpQi+9ZVO1ruvzroZVB/w+1UE3XyNeD7Ewn0ZcdzAy2UIuL/eiU98Y/aJQfUBv99A0M3aE8zFa4+Yi9fpJBd/k+jcLetfdpk5bbmWPhnXRi+HLIIx0gnPsxTSq3aKY0PblPpgYxElcZWdl8zFaFDfp+3yifRvbN8C3V2O4Fvf6mS9u2LWzaD6gN8rEHTzbeL5EAv3lcRxAy9XIuD+Tic+cdXsE4PqA36vQtDNXSeYi+86Yi5et5Nc/F2ic7fYP24zt6xYCbfuFy9E8lLVhihkmYSrTpfKVRQ8WalV+9vCO7jNyRpv245VYfbv6on0b2zfAt1djeBb3+tkvfv+rJtB9QG/30fQzQ+I50Ms3NcQxw28XIOA+4ed+MSPZp8YVB/w+yME3dx9grn47iPm4vU7ycU/Jjp3y/rnSzaSZcXaaQx82nqQqsHWXCeeojSundkwnVQuWZhcpTNaZOFZFKa2s52K2b9rJ9K/sX0LdHctgm/9pJP17qezbgbVB/z+FEE3PyOeD7FwX0ccN/ByHQLun3fiE9fPPjGoPuD3egTd3HOCufieI+biDTvJxb8gOneL/RNRS8e9khnuWZIxM+2DsspGK2ri3FTmfVKGMZWT4zznqBSr8HE6DTNH/RzoGybSv7F9C3R3A4Jv/bKT9e5Xs24G1Qf8/gpBN78mng+xcN9IHDfwciMC7t904hM3zT4xqD7g9yYE3dxngrn4PiPm4o06ycW/JTp3y/rHc9uBFu9s8UYn2IAmJrQo3uboYo3WGeNy25n6lKtJFmaOtWmNWYsoI2b/bp5I/8b2LdDdzQi+9btO1rvfz7oZVB/w+3sE3fyBeD7Ewn0LcdzAyy0IuP/YiU/8afaJQfUBv39C0M39JpiL7zdiLt6kk1z8Z6Jzt9g/HrhLzpvKhUpZOcFrLMyFZBxrMyeNSFxLpQz3qVRmhbOqKmk9vHdMFRKzf7dOpH9j+xbo7lYE3/pLJ+vdX2fdDKoP+P0rgm7+RjwfYuG+jThu4OU2BNx/78QnllaffWJIfcAv9G5s3Txggrn4ASPm4s06ycV3IDp3my173/C22QyVlVBEqm1PWk2UisWaFdzkz5Nq4G2stRpvuIS3f/FWiNIeo9vcofZvhYn0b2zfAt2tgOBbd1y9j7lbcdbNoPqA3xURdHOnkXXTC+6ViOMGXlZCwL1yJz6xyuwTg+oDfldB0M2DJ5iLHzxiLt68k1y8KtG5W+wfzzVrZ60wJSkltNElKlvbWY1UVjEjVTTaiMyjYdwLryxvU+mMZSEoxlHfj2K1ifRvbN8C3a2G4Furd7LerTHrZlB9wO8aCLpZk3g+xMK9FnHcwMtaCLjX7sQn1pl9YlB9wO86CLp56ARz8UNHzMWsk1x8Z6Jzt9g/rmzwTMWUuQ2yGlNitvCRk1xYr5ltDy+GCadEYMq2wauZc58lL7lKL1Bz8V0m0r+xfQt0dxcE37prJ+vdurNuBtUH/K6LoJu7Ec+HWLjXI44beFkPAffdO/GJ9WefGFQf8Ls+gm7kBHOxHDEXq05y8T2Izt3y/hnBuVHFxTZ4yhre8BYRQsw+8GBsSYnp6oWJJekYQyrRaqEMN6X9PYPZvw0m0r+xfQt0twGCb92zk/Vuw1k3g+oDfjdE0M29iOdDLNz3Jo4beLk3Au77dOITG80+Mag+4HcjBN3YCeZiO2Iudp3k4vsSnbvF/gnHakrF8zZaLJoGphRZTHDShRgTr7ad26iinJZRiMyMDdpUXTxzyjfcmP3beCL9G9u3QHcbI/jW/TpZ7zaZdTOoPuB3EwTd3J94PsTCvSlx3MDLphivn+rEJzabfWJQfcDvZgi6edgEc/HDRszFW3WSix9IdO4W+yey8pnJEE20iiuvi8o2xdLmL5hUWWUmlODaqAmXuczaVhNYe1RyxmUWMfv3oIn0b2zfAt09CON1EZ2sd5vPuhlUH/C7OYJuHkI8H2Lh3oI4buBlC4z7RDvxCTb7xKD6gF+GoJtHTjAXP3LEXPyoTnIxJzp3i/0TQftoiuLMaZG9MYYr67lt+00eqnRVWRetYbJEWVQVsm1cvZEyO2FSLqjXi8VE+je2b4HuBMb9X52sd2rWzaD6gF+FoBtNPB9i4TbEcQMvBuM8vBOfcLNPDKoP+HUIunnMBHPxY0bMxdt0kos90bnbZtn7I1rrZA2+Vhulye14Bm5QKkanmlwbLhYty/B5OlHzELVVuuhaeE5SZx85Zv+2nEj/xvYt0N2WGOdcnax3W826GVQf8LsVgm4eTjwfYuF+BHHcwMsjMK77deITj5p9YlB9t/OLoJvHTTAXP27EXLxdJ7n40UTnbrtl9y+ZzIstTPoabv8mZleL8YW36UshG268TKkBa+CVU5Z7HkMRtUqlosDs39YT6d/YvgW62xpjP9/JerfNrJtB9QG/2yDo5rHE8yEW7m2J4wZetsXIN534xHazTwyqD/jdDkE3T5hgLn7CiLl4h05y8eOJzt2y/tXQjmhyLK5wVVzSkjUAPoTaDmSczyFGmRMTptaSIlM+y2xiG7jU2sGsxezf9hPp39i+BbrbHsO3Olnvdph1M6g+4HcHBN08kXg+xMK9I3HcwMuOCLif1IlP7DT7xKD6gN+dMHQzwVz8pBFz8U6d5OInE527Zf0rbYa0kboG3VAxJ3xqoKRIShoea7Al11wVi0xzlRjLWQYrpWs9qdyjfg70zhPp39i+BbrbGcG3ntLJerfLrJtB9QG/uyDo5qnE8yEW7l2J4wZedkXA/bROfGK32ScG1Qf87oaxvkwwFz9lxFy8Sye5+OlE526xf0JGVoLl0cWYZYpGwOteixa66uSi1CnWkp1gsEMVUsFrY5XROuVqeTvcwezf7hPp39i+BbrbHcG3ntHJerfHrJtB9QG/eyDo5pnE8yEW7j2J4wZe9kTA/axOfGKv2ScG1Qf87oWxn5pgLn7aiLl4t05ycSA6d7ste71rKllbkWPNwhiljWeS1VSl54w3WKJa32YvFtmOZbhyXtVYk23wQ5vBitm/OJH+je1boLuI4Fupk/Uuz7oZVB/wmxF0U4jnQyzclThu4KUi4H52Jz6x9+wTg+oDfvfGuO4ywVz8jBFz8R6d5OLnEJ27Zf2TSZooFctc5FCFEqKWmLkOSgteZTuc0Z5pm0SoNTfoJhlbg2xb1ZTa9hSzf/tMpH9j+xbobh8E33puJ+vdvrNuBtUH/O6LoJvnEc+HWLj3I44beNkPAffzO/GJ/WefGFQf8Ls/xjnDBHPxs0bMxXt1kotfQHTuFvvHbTYqwRZUeGl8Yr6NlxY+WS1FdG0MHbz4tZqcfYbb/A2TMTiTohe6NQezfwdMpH9j+xbo7gAE33phJ+vdgbNuBtUH/B6IoJsXEc+HWLgPIo4beDkIAfeLO/GJg2efGFQf8HswxnnkBHNxGjEX505y8UuIzt2y/nnNNJMNiOLSFJWsjKqd0ITImIvVCB2sTJqHNo3F2up9MsykYNv5jpEZNRcfMpH+je1boLtDEHzrpZ2sd4fOuhlUH/B7KIJuXkY8H2LhPow4buDlMATcL+/EJw6ffWJQfcDv4Rj330wwFz97xFy8dye5+BVE526xf5ylwGoWweuYuHe2DZO0umpjuBPKyMKSFyVwIXI1yunKkyo6eGt8lCJh9u+IifRvbN8C3R2B4Fuv7GS9O3LWzaD6gN8jEXTzKuL5EAv3UcRxAy9HIeB+dSc+cfTsE4PqA36PxrhPb4K5+Lkj5uJ9O8nFryE6d4v9E74ambzUpRYhVBFSZx1Vw+q0dW28otBtj+qDVCKrwLJv21TvSrXa5mhQP+/umIn0b2zfAt0dg+Bbr+1kvTt21s2g+oDfYxF08zri+RAL93HEcQMvxyHgfn0nPnH87BOD6gN+j8e4L32Cufj5I+bi/TvJxW8gOneL/eOFC9eQlVrbXEkeuXUxeW1TYknxwLMV0jJt4X4lUzPzrESZjDQm+lI1Zv9OmEj/xvYt0N0JCL71xk7WuxNn3QyqD/g9EUE3byKeD7Fwn0QcN/ByEgLuN3fiE2+ZgE/ccUE38LXiuBpya7cfsM4dR3s+9fM7LS1df6fxMuznVllaumCV8bgBbYNuxu7jquM9l1ptvOcSq4/oN2ss4fgCfO3xj39DH1f4lz9baeH3jxrp56+0NLofsyb7pTv947nW+kfd4+qMM+jPHf+lP3f4l+8ftfD7FRd6eCeEHq406nPaCM+x8kL9/8T6z9pXX/jzlRb+vfK42PgdFn7mP5/3n9+vjPZzxe2fb7rK/4J/lX9Txyr/RfyroP1cczv/q/4v+Ff9N3Ws+l/EvyrazzW3vy/rav8L/tX+TR2r/Rfxr4b2c035J8b/P/yr/5s6Vv8v4l8d7ecaBc+xxv+Cf41/U8ca/0X8ayz8XAz/+7/iX5kA/nF/rgzwHGv+L/jX/Dd1rPlfxL/mws/F4P//in9lAvjH/bnGwHOs9b/gX+vf1LHWfxH/Wgs/F2P9+7/iX5UA/nF/rrn9uuDa/wv+tf9NHWv/F/GvjfZzze33x63zv+Bf59/Usc5/Ef86Cz8XY/3/v+JfnQB+DP//v+JfmQD+cX+uvf19tu78v+C/87+p487/Rfx3Xvi5Y19TgD3dP3nd/4Dn7Hfgvvv9ayvg65+XiO6w8N8XZbO4Vf/XyyOj9Whpafxr+v+8Pjn6ewt1cs8C1vXK//g9jzrp39/WHK9/Lxzxno8X9dE/NeY9MweO2L+DOunfiSP270Uj9u/Fndxz9NYRzzRH1Axf1r8GxiVbPa9FmWp4+x8TNnLusglKu5BijFZ4mc3tLxs3KobgvQmlwnf/eqb5z6+x19IRe8kW6z154QLlP89XVvg3mkA4Y/r/vI7hX/u41lJngQdIOnn18Z/3bauPN5RYuN+2+ugcLTMnyj1dfaHGFf4hZhgmSO6Q2mEjABd44CL/Py/6/hPP4oHw/wO44KOqS5IOAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/modules/target/main.json b/crates/nargo_cli/tests/test_data/modules/target/modules.json similarity index 100% rename from crates/nargo_cli/tests/test_data/modules/target/main.json rename to crates/nargo_cli/tests/test_data/modules/target/modules.json diff --git a/crates/nargo_cli/tests/test_data/modules_more/target/main.json b/crates/nargo_cli/tests/test_data/modules_more/target/modules_more.json similarity index 100% rename from crates/nargo_cli/tests/test_data/modules_more/target/main.json rename to crates/nargo_cli/tests/test_data/modules_more/target/modules_more.json diff --git a/crates/nargo_cli/tests/test_data/modulus/target/main.json b/crates/nargo_cli/tests/test_data/modulus/target/modulus.json similarity index 100% rename from crates/nargo_cli/tests/test_data/modulus/target/main.json rename to crates/nargo_cli/tests/test_data/modulus/target/modulus.json diff --git a/crates/nargo_cli/tests/test_data/nested_arrays_from_brillig/target/main.json b/crates/nargo_cli/tests/test_data/nested_arrays_from_brillig/target/nested_arrays_from_brillig.json similarity index 100% rename from crates/nargo_cli/tests/test_data/nested_arrays_from_brillig/target/main.json rename to crates/nargo_cli/tests/test_data/nested_arrays_from_brillig/target/nested_arrays_from_brillig.json diff --git a/crates/nargo_cli/tests/test_data/unit/target/main.json b/crates/nargo_cli/tests/test_data/numeric_generics/target/numeric_generics.json similarity index 100% rename from crates/nargo_cli/tests/test_data/unit/target/main.json rename to crates/nargo_cli/tests/test_data/numeric_generics/target/numeric_generics.json diff --git a/crates/nargo_cli/tests/test_data/option/Nargo.toml b/crates/nargo_cli/tests/test_data/option/Nargo.toml new file mode 100644 index 00000000000..2248e9c06dd --- /dev/null +++ b/crates/nargo_cli/tests/test_data/option/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "option" +authors = [""] +compiler_version = "0.7.0" + +[dependencies] diff --git a/crates/nargo_cli/tests/test_data/option/src/main.nr b/crates/nargo_cli/tests/test_data/option/src/main.nr new file mode 100644 index 00000000000..0a41b9a629c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/option/src/main.nr @@ -0,0 +1,53 @@ +use dep::std::option::Option; + +fn main() { + let none = Option::none(); + let some = Option::some(3); + + assert(none.is_none()); + assert(some.is_some()); + + assert(some.unwrap() == 3); + + assert(none.unwrap_or(2) == 2); + assert(some.unwrap_or(2) == 3); + + assert(none.unwrap_or_else(|| 5) == 5); + assert(some.unwrap_or_else(|| 5) == 3); + + assert(none.map(|x| x * 2).is_none()); + assert(some.map(|x| x * 2).unwrap() == 6); + + assert(none.map_or(0, |x| x * 2) == 0); + assert(some.map_or(0, |x| x * 2) == 6); + + assert(none.map_or_else(|| 0, |x| x * 2) == 0); + assert(some.map_or_else(|| 0, |x| x * 2) == 6); + + assert(none.and(none).is_none()); + assert(none.and(some).is_none()); + assert(some.and(none).is_none()); + assert(some.and(some).is_some()); + + let add1_u64 = |value: Field| Option::some(value as u64 + 1); + + assert(none.and_then(|_value| Option::none()).is_none()); + assert(none.and_then(add1_u64).is_none()); + assert(some.and_then(|_value| Option::none()).is_none()); + assert(some.and_then(add1_u64).unwrap() == 4); + + assert(none.or(none).is_none()); + assert(none.or(some).is_some()); + assert(some.or(none).is_some()); + assert(some.or(some).is_some()); + + assert(none.or_else(|| Option::none()).is_none()); + assert(none.or_else(|| Option::some(5)).is_some()); + assert(some.or_else(|| Option::none()).is_some()); + assert(some.or_else(|| Option::some(5)).is_some()); + + assert(none.xor(none).is_none()); + assert(none.xor(some).is_some()); + assert(some.xor(none).is_some()); + assert(some.xor(some).is_none()); +} diff --git a/crates/nargo_cli/tests/test_data/1_mul/target/c.json b/crates/nargo_cli/tests/test_data/option/target/option.json similarity index 59% rename from crates/nargo_cli/tests/test_data/1_mul/target/c.json rename to crates/nargo_cli/tests/test_data/option/target/option.json index c1233b8160b..4c3bb072cb3 100644 --- a/crates/nargo_cli/tests/test_data/1_mul/target/c.json +++ b/crates/nargo_cli/tests/test_data/option/target/option.json @@ -1 +1 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":[155,194,56,97,194,4,0],"proving_key":null,"verification_key":null} \ No newline at end of file +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/2NkIAwAQGbG/yQAAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/option/target/witness.tr b/crates/nargo_cli/tests/test_data/option/target/witness.tr new file mode 100644 index 00000000000..4e90289d5e1 Binary files /dev/null and b/crates/nargo_cli/tests/test_data/option/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/pedersen_check/target/main.json b/crates/nargo_cli/tests/test_data/pedersen_check/target/pedersen_check.json similarity index 100% rename from crates/nargo_cli/tests/test_data/pedersen_check/target/main.json rename to crates/nargo_cli/tests/test_data/pedersen_check/target/pedersen_check.json diff --git a/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/main.json b/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/main.json deleted file mode 100644 index ead0faac568..00000000000 --- a/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x1","type":{"kind":"array","length":2,"type":{"kind":"field"}},"visibility":"private"},{"name":"y1","type":{"kind":"field"},"visibility":"public"},{"name":"x2","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"},{"name":"y2","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x1":[1,2],"x2":[4,5,6,7],"y1":[3],"y2":[8]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/poseidon_bn254_hash.json b/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/poseidon_bn254_hash.json new file mode 100644 index 00000000000..7f4e9fa4143 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/poseidon_bn254_hash/target/poseidon_bn254_hash.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x1","type":{"kind":"array","length":2,"type":{"kind":"field"}},"visibility":"private"},{"name":"y1","type":{"kind":"field"},"visibility":"public"},{"name":"x2","type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"private"},{"name":"y2","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x1":[1,2],"x2":[4,5,6,7],"y1":[3],"y2":[8]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/poseidonsponge_x5_254/target/main.json b/crates/nargo_cli/tests/test_data/poseidonsponge_x5_254/target/poseidonsponge_x5_254.json similarity index 100% rename from crates/nargo_cli/tests/test_data/poseidonsponge_x5_254/target/main.json rename to crates/nargo_cli/tests/test_data/poseidonsponge_x5_254/target/poseidonsponge_x5_254.json diff --git a/crates/nargo_cli/tests/test_data/pred_eq/target/main.json b/crates/nargo_cli/tests/test_data/pred_eq/target/pred_eq.json similarity index 100% rename from crates/nargo_cli/tests/test_data/pred_eq/target/main.json rename to crates/nargo_cli/tests/test_data/pred_eq/target/pred_eq.json diff --git a/crates/nargo_cli/tests/test_data/rebuild.sh b/crates/nargo_cli/tests/test_data/rebuild.sh index c84cdae3af0..53d18e5cc93 100755 --- a/crates/nargo_cli/tests/test_data/rebuild.sh +++ b/crates/nargo_cli/tests/test_data/rebuild.sh @@ -21,7 +21,10 @@ for dir in ./*; do dir_name=$(basename "$dir") if [[ ! " ${exclude_fail_dirs[@]} " =~ " ${dir_name} " ]]; then cd $dir - nargo compile main && nargo execute witness + if [ -d ./target/ ]; then + rm -r ./target/ + fi + nargo compile && nargo execute witness cd .. fi done diff --git a/crates/nargo_cli/tests/test_data/references/src/main.nr b/crates/nargo_cli/tests/test_data/references/src/main.nr index d2c0b7f1244..f70293cb5a6 100644 --- a/crates/nargo_cli/tests/test_data/references/src/main.nr +++ b/crates/nargo_cli/tests/test_data/references/src/main.nr @@ -30,6 +30,9 @@ fn main(mut x: Field) { }; *c.bar.array = [3, 4]; assert(*c.bar.array == [3, 4]); + + regression_1887(); + regression_2054(); } fn add1(x: &mut Field) { @@ -58,3 +61,29 @@ impl S { fn mutate_copy(mut a: Field) { a = 7; } + +// Previously the `foo.bar` in `foo.bar.mutate()` would insert an automatic dereference +// of `foo` which caused the method to wrongly be mutating a copy of bar rather than the original. +fn regression_1887() { + let foo = &mut Foo { bar: Bar { x: 0 } }; + foo.bar.mutate(); + assert(foo.bar.x == 32); +} + +struct Foo { bar: Bar } +struct Bar { x: Field } + +impl Bar { + fn mutate(&mut self) { + self.x = 32; + } +} + +// Ensure that mutating a variable does not also mutate its copy +fn regression_2054() { + let mut x = 2; + let z = x; + + x += 1; + assert(z == 2); +} diff --git a/crates/nargo_cli/tests/test_data/references/target/main.json b/crates/nargo_cli/tests/test_data/references/target/references.json similarity index 100% rename from crates/nargo_cli/tests/test_data/references/target/main.json rename to crates/nargo_cli/tests/test_data/references/target/references.json diff --git a/crates/nargo_cli/tests/test_data/regression/target/main.json b/crates/nargo_cli/tests/test_data/regression/target/main.json deleted file mode 100644 index 02e3d0eb75b..00000000000 --- a/crates/nargo_cli/tests/test_data/regression/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"z","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1,2,3,4,5],"z":[6]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/regression/target/regression.json b/crates/nargo_cli/tests/test_data/regression/target/regression.json new file mode 100644 index 00000000000..30a0ff778f8 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/regression/target/regression.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":5,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"z","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1,2,3,4,5],"z":[6]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/regression/target/witness.tr b/crates/nargo_cli/tests/test_data/regression/target/witness.tr index ff04a722861..72f6196007b 100644 Binary files a/crates/nargo_cli/tests/test_data/regression/target/witness.tr and b/crates/nargo_cli/tests/test_data/regression/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/regression_2099/Nargo.toml b/crates/nargo_cli/tests/test_data/regression_2099/Nargo.toml new file mode 100644 index 00000000000..ca96e7164a5 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/regression_2099/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "regression_2099" +authors = [""] +compiler_version = "0.9.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/regression_2099/src/main.nr b/crates/nargo_cli/tests/test_data/regression_2099/src/main.nr new file mode 100644 index 00000000000..b96e664dedf --- /dev/null +++ b/crates/nargo_cli/tests/test_data/regression_2099/src/main.nr @@ -0,0 +1,37 @@ +use dep::std::ec::tecurve::affine::Curve as AffineCurve; +use dep::std::ec::tecurve::affine::Point as Gaffine; +use dep::std::ec::tecurve::curvegroup::Curve; +use dep::std::ec::tecurve::curvegroup::Point as G; + +use dep::std::ec::swcurve::affine::Point as SWGaffine; +use dep::std::ec::swcurve::curvegroup::Point as SWG; + +use dep::std::ec::montcurve::affine::Point as MGaffine; +use dep::std::ec::montcurve::curvegroup::Point as MG; + +fn main() { + // Define Baby Jubjub (ERC-2494) parameters in affine representation + let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905)); + + // Test addition + let p1_affine = Gaffine::new(17777552123799933955779906779655732241715742912184938656739573121738514868268, 2626589144620713026669568689430873010625803728049924121243784502389097019475); + let p2_affine = Gaffine::new(16540640123574156134436876038791482806971768689494387082833631921987005038935, 20819045374670962167435360035096875258406992893633759881276124905556507972311); + let _p3_affine = bjj_affine.add(p1_affine, p2_affine); + + // Test SWCurve equivalents of the above + // First the affine representation + let bjj_swcurve_affine = bjj_affine.into_swcurve(); + + let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine); + let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine); + + let _p3_swcurve_affine_from_add = bjj_swcurve_affine.add( + p1_swcurve_affine, + p2_swcurve_affine + ); + + // Check that these points are on the curve + assert( + bjj_swcurve_affine.contains(p1_swcurve_affine) + ); +} diff --git a/crates/nargo_cli/tests/test_data/regression_2099/target/regression_2099.json b/crates/nargo_cli/tests/test_data/regression_2099/target/regression_2099.json new file mode 100644 index 00000000000..4c3bb072cb3 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/regression_2099/target/regression_2099.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/2NkIAwAQGbG/yQAAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/regression_2099/target/witness.tr b/crates/nargo_cli/tests/test_data/regression_2099/target/witness.tr new file mode 100644 index 00000000000..4e90289d5e1 Binary files /dev/null and b/crates/nargo_cli/tests/test_data/regression_2099/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/main.json b/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/main.json deleted file mode 100644 index bcd3cb00647..00000000000 --- a/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/82Y7WqDMBSG47YaYzTqnWi3pexf72O/9vVjMMoYu3/WrAkc2tMm0HNCAiUW5X3exwMKVkKIShzWLTjG1tbv83VrOc599rva/26OztX0/LkGnlSZq33GymcZ3/uOlLHMys8IrurMjATg16AbTZfDPaxJMzevLkOC/sE1dNfgfA12Seu2VIAZcsN/ycZdr11GE/FvkB5NRv+GjWv/568i/grpoTL6KzaufXIZbcS/RXq0Gf1bNq79CI6X/DXSQ2f012xc++Ayuoh/h/ToMvp3gMvx/Ev1lwX403LvX1xGH/HvkR59Rv8ecDnmn+ovC/Cn5VrrMkzE3yA9TEZ/A7gc779Uf1WAPy3XPrqMIeI/ID2GjP4DG9e+uYwx4j8iPcaM/iPgcrz/U/11Af4cz/9Uf1mAPy138+4ypoj/hPSYMvoHVgNm8P3zufv92oXL4SeccFwBHTjCk89NWyIHcWb9AWoqKyjwEgAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/regression_method_cannot_be_found.json b/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/regression_method_cannot_be_found.json new file mode 100644 index 00000000000..fa1ea51d9d6 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/regression_method_cannot_be_found/target/regression_method_cannot_be_found.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/82Y20rEMBCGU3Wbpue+SbtqFu/2QbzxdCHIIuL7446bwFBnTWBnQgZKeoD//79MaUkKpVShTnWNzqnau3G+rJa17qMbzfG4Wj0r+f3nEnFyaW6OGhun1bvcN6wey2xcj3AVZ3qkkH+JsvFkOc1hyaq5ewYNjfJ7Vp+9Qc9LNGpetqVAnl7XX2sx3+0WNKoAf0XkqBLyV2K+9rf/JsBviBwmIb8R87UPoFEH+GsiR52QvxbztW+e8T/+hsjRJORvxHztHWi0Af6WyNEm5G+Rr8T3L5ZfZ8DP63v7BBpdgL8jcnQJ+TvkK9H/WH6dAT+vr7Wg0Qf4eyJHn5C/R74S/79YfpMBP6+vvQeNIcA/EDmGhPyDmK99AY0xwD8SOcaE/CPylfj/x/I3GfBLfP9j+XUG/Ly+u1fQmAL8E5FjSsg/IV/uPQVY0/m+fn69H74/DuupgPJbRAW6j18bvFT/s521Z5ojdaZ+ACQMHzFQEwAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Nargo.toml b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Nargo.toml new file mode 100644 index 00000000000..3e411b2849b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "ret_fn_ret_cl" +authors = [""] +compiler_version = "0.7.1" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Prover.toml b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Prover.toml new file mode 100644 index 00000000000..3a627b9188b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/Prover.toml @@ -0,0 +1 @@ +x = "10" diff --git a/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/src/main.nr b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/src/main.nr new file mode 100644 index 00000000000..d3a3346b541 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/src/main.nr @@ -0,0 +1,39 @@ +use dep::std; + +fn f(x: Field) -> Field { + x + 1 +} + +fn ret_fn() -> fn(Field) -> Field { + f +} + +// TODO: in the advanced implicitly generic function with closures branch +// which would support higher-order functions in a better way +// support returning closures: +// +// fn ret_closure() -> fn(Field) -> Field { +// let y = 1; +// let inner_closure = |z| -> Field{ +// z + y +// }; +// inner_closure +// } + +fn ret_lambda() -> fn(Field) -> Field { + let cl = |z: Field| -> Field { + z + 1 + }; + cl +} + +fn main(x : Field) { + let result_fn = ret_fn(); + assert(result_fn(x) == x + 1); + + // let result_closure = ret_closure(); + // assert(result_closure(x) == x + 1); + + let result_lambda = ret_lambda(); + assert(result_lambda(x) == x + 1); +} diff --git a/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/ret_fn_ret_cl.json b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/ret_fn_ret_cl.json new file mode 100644 index 00000000000..2b779b1d05e --- /dev/null +++ b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/ret_fn_ret_cl.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1Uyw4CIQzsvo0Hv6VdYLfc/BWJ7P9/gjFyaHD1QknWxLmUQDKdTsmcAOAM72hSvaZqcLE2rnMkQzecfWCH1oWFicmxu89sTGTLqw9+RU/WRNqcNxu+0AouLEQn9H3TjGUgTc1SbyfOfartzvtYYSbI+uQ+XnbuVJvXWFJXgbcHvc9fa+5ef0coKA/v6SedpdwD/F5YaWqWekdx/odVIedQyagJjh1Wz7kn/R1VDStNT5tMo8QDRfQaNoIJAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/witness.tr b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/witness.tr new file mode 100644 index 00000000000..7990c4fa02d Binary files /dev/null and b/crates/nargo_cli/tests/test_data/ret_fn_ret_cl/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/scalar_mul/target/main.json b/crates/nargo_cli/tests/test_data/scalar_mul/target/scalar_mul.json similarity index 100% rename from crates/nargo_cli/tests/test_data/scalar_mul/target/main.json rename to crates/nargo_cli/tests/test_data/scalar_mul/target/scalar_mul.json diff --git a/crates/nargo_cli/tests/test_data/schnorr/target/main.json b/crates/nargo_cli/tests/test_data/schnorr/target/main.json deleted file mode 100644 index 5c80b2f055b..00000000000 --- a/crates/nargo_cli/tests/test_data/schnorr/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"array","length":10,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_x","type":{"kind":"field"},"visibility":"private"},{"name":"pub_key_y","type":{"kind":"field"},"visibility":"private"},{"name":"signature","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"message":[1,2,3,4,5,6,7,8,9,10],"pub_key_x":[11],"pub_key_y":[12],"signature":[13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+WW6U7bQBhFHdK0Cd33vU3pvtuxndillFBKgbK8QyPC+z8BIlf5rjDnFxI/GckaHcma2ON77mQ/SZL9ZD5as2sh5m6DF8Bt8CVwB3wZfAXcBffAi8GdeM5FPG87nqETv+X1e3Gv77uOdW+Ab4JvgW+D74Dvgu+B74MfgB+CH4Efg5+An4KfgZ+DX4BfgvvgV+Al8GvwG/Bb8Dvwe/AH8EfwJ/Bn8BfwV/A38HdwCs7AA3AOLsAleAgegStwDf4BXgb/BK+Af4FXwWPwGvg3eB38B7wB/gveBG+Bt8H/wDvg3eSkN9rxPhrqAbkv3+W4vJbL8lfOylO5KR/loLyTa/JLTskjuSNf+snci6Vknn9lXjlXtpVnZVi5VVaVT2VSOVT2lDdlTLlSlpQfZUY5UTaUB2Wgjm+9HN90Jb7darzTWnyL9djzjdjbzdjD7dirndiTVuzJ1dl1NLuuxdzcn25y0o/uRfehe9D9595z37nn3G/uNfeZe8z95d5yX7mn3E/upX7M7iH3j3vHfeOecb+4V9wn7hH3h3vDfeGecD+4F9wH7gH7b+/tuz233/baPttj+2tv7as9tZ/2chyzPbR/9s6+2TP7Za+2YrZH9sfe2Jfm+Sr2Ge1z3+e9z3mf7z53ffUa62neS06PVszjmNPzjWyvsVaeDotiOhpMszz7nw7qSVWmRTkZVlmVlVV5MKjyfFoV1aie1KO0zop8mh2WdX4Yi+02nvEs/zHkkjy66N3CcQxDe3abYAoAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/schnorr/target/schnorr.json b/crates/nargo_cli/tests/test_data/schnorr/target/schnorr.json new file mode 100644 index 00000000000..4d453d243f5 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/schnorr/target/schnorr.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"array","length":10,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"pub_key_x","type":{"kind":"field"},"visibility":"private"},{"name":"pub_key_y","type":{"kind":"field"},"visibility":"private"},{"name":"signature","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"message":[1,2,3,4,5,6,7,8,9,10],"pub_key_x":[11],"pub_key_y":[12],"signature":[13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+WW6W7TQBhFJy2BpOz7DqHsux3biU0pTSmlLV3egYj0/Z8Akat8VzXnFxI/O5I1OpI1scf33MlRSukoLUZnfi3F3GvxEngZfAbcBZ8FnwP3wH3wSnA3nnMFz7scz9CN3/L6/bjX913EupfAl8FXwFfB18DXwTfAN8G3wLfBd8B3wffA98EPwA/Bj8CPwQPwE/Aq+Cn4Gfg5+AX4JfgV+DX4Dfgt+B34PfgD+CM4A+fgIbgAl+AKPAKPwTW4AX8Cr4E/g9fBX8Ab4Al4E/wVvAX+Bt4GfwfvgHfBe+Af4H3wQTrpjU68j4Z6QO7Ldzkur+Wy/JWz8lRuykc5KO/kmvySU/JI7siXQVp4sZoW+VfmlXNlW3lWhpVbZVX5VCaVQ2VPeVPGlCtlSflRZpQTZUN5UAaa+NZr8U3X49ttxDttxrfYij3fjr3diT3ci73ajz3pxJ6cn1+/59eFmNv700sn/ehedB+6B91/7j33nXvO/eZec5+5x9xf7i33lXvK/eReGsTsHnL/uHfcN+4Z94t7xX3iHnF/uDfcF+4J94N7wX3gHrD/9t6+23P7ba/tsz22v/bWvtpT+2kvJzHbQ/tn7+ybPbNf9mo3Zntkf+yNfWmfr2Kf0T73fd77nPf57nPXV7+1nubD9PfoxDyJOfu/kR+21iqyUVnOxsNZXuQ/s2EzrausrKajOq/zqq5+DeuimNVlPW6mzThr8rKY5cdVUxzHYgetZ/yX/xhySR6d9m7h+APZ/ELmYAoAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha256/target/main.json b/crates/nargo_cli/tests/test_data/sha256/target/main.json deleted file mode 100644 index 5fd48602f5b..00000000000 --- a/crates/nargo_cli/tests/test_data/sha256/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha256/target/sha256.json b/crates/nargo_cli/tests/test_data/sha256/target/sha256.json new file mode 100644 index 00000000000..5034bb8f814 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/sha256/target/sha256.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2d/ZPNVRzH37vL2iVPSZKE8vx47z7Yu54fQoQQQojNbgghhBBCCCGEEEIIIYQQzfQv9Wudzzh3fOaQX877zHzPzPfOfGbPB73v+/P+3H2dht27fwH4G48fBaYKbZWovsjp6zl9facvdvoGTl/i9KVO39DpGzn9C07f2OmbOH1Tp2/m9M2d/kWnb+H0Lzl9S6d/2elbOf0rTt/a6V91+jZO/5rTt3X6152+ndO3d/oOtpc9wv4+8GT39ezvFatdlto9NbL7aGxzb2rzbW5zbGHzamlzaWXnb23nbGPnaWt9t7PP38E+dxGefhTYj0Psx4zfI1vA08o8wy5HOxtQ26gXKs037Mc31a+V2o95PsijWO0jvyd5rfyLp3dVoM6F9s8UPefPFPyPTqn6tfx/30R5AS+TTDHor7VME6XJNpzNf0LLAv/Bk09wWWSJ85xFAZ47r1We6VtRUVtVVpstz87NlFXX5CozFZU1fXPZXLYyVzmvLFdeXpuryFVV11RXZaqzFeW12brK6vLaOnlksm8QtOqssTd5M2byL/T8AvO5trd9R1OdTHU21cVUV1PdTHU31cNUT1O9TPU21Uf8mMqaKpM5TVWYqjTV11SVqZypalP9TPU3NcDUQFODTA22cw01NczUcDx/v745FhJfKx2Jvt4i7lfvVj/YFw7Ts/Y7Qp3r2Y+Fz3hNBABbFs7zuDkGBV+oJY0IoDsSvBd/qLlH8neUcV8gIOZQRJy/E9HXKMQHJ6Zn7fdtdU7h5Kk5ygbK1h2NZMNJ5h7N31FQONUjzt+Z6GsM4oMT07P2+446p3Dy1BxjA2XrjkWy4SRzj+XvKIhX+T+80c/Q9c11HOKAcn1ill2IvsYjPigzPWu/76pzCmVPzfE2ULbuBCQbyjL3BP6OgniVy2Mc+FCeiDigXEzMsivR1yTEB2WmZ+33PXVOoeypOckGytadjGRDWeaezN9REK9yeUwEH8pTEAeUGxCz7Eb0NRXxQZnpWft9X51TKHtqTrWBsnWnIdlQlrmn8XcUxKtcHlPAh/J0xAHlEmKW3Ym+ZiA+KDM9a78fqHMKZU/NGTZQtu5MJBvKMvdM/o6CeJXLYzr4UJ6FOKBcSsyyB9HXbMQHZaZn7fdDdU6h7Kk52wbK1p2DZENZ5p7D31EQr3J5zAIfynMRB5QbErPsSfRVg/igzPSs/X6kzimUPTVrbKBs3XlINpRl7nn8HQXxOsdozAUfyrWIA8qNiFn2IvqqQ3xQZnrWfj9W5xTKnpp1NlC27nwkG8oy93z+joJ4lcujFnwoL0AcUH6BmGVvoq+FiA/KTM/a7yfqnELZU3OhDZStuwjJhrLMvYi/oyBe5fJYAD6UFyMOKDcmZtmH6GsJ4oMy07P2+6k6p1D21FxiA2XrLkWyoSxzL+XvKIhXuTwWgw/lZYgDyk2IWWaIvpYjPigzPWu/n6lzCmVPzeU2ULbuCiQbyjL3Cv6OgniVy2MZ+FBeiTig3JSYZZboaxXigzLTs/b7uTqnUPbUXGUDZeuuRrKhLHOv5u8oiFe5PFaCD+U1iAPKzYhZlhF9rUV8UGZ61n6/UOcUyp6aa22gbN11SDaUZe51/B0F8SqXxxrwobwecUC5OTHLcqKvDYgPykzP2u+X6pxC2VNzgw2UrbsRyYayzL2Rv6MgXuXyWA8+lDchDii/SMyyguhrM+KDMtOz9vuVOqdQ9tTcbANl625BsqEsc2/h7yiI141GYxP4UN6KOKDcgphlJdHXNsQHZaZn7fdrdU6h7Km5zQbK1t2OZENZ5t7O31EQr3J5bAUfyjsQB5RfImbZl+hrJ+KDMtOz9vuNOqdQ9tTcaQNl6+5CsqEsc+/i7yiIV7k8doAP5d2IA8otiVlWEX3tQXxQZnrWfr9V5xTKnpp7bKBs3b1INpRl7r38HQXxKpfHbvChvA9xQPllYpY5oq/9iA/KTM/a73fqnELZU3O/DZStewDJhrLMfYC/oyBe5fLYBz6UDyIOKLciZllN9HUI8UGZ6Vn7/V6dUyh7ah6ygbJ1DyPZUJa5D/N3FMSrXB4HwYfyEcQB5VeIWfYj+jqK+KDM9Kz9/qDOKZQ9NY/aQNm6x5BsKMvcx/g7CuJVLo8j4EP5OOKAcmtilv2Jvk4gPigzPWu/P6pzCmVPzRM2ULbuSSQbyjL3Sf6OgniVy+M4+FA+hTig/CoxywFEX6cRH5SZnrXfn9Q5hbKn5mkbKFv3DJINZZn7DH9HQbyeNBqnwIfyWcQB5TbELAcSfZ1DfFBmetZ+f1bnFMqemudsoGzd80g2lGXu8/wdBfEql8dZ8KF8AXFA+TViloOIvi4iPigzPWu/v6hzCmVPzYs2ULbuJSQbyjL3Jf6OgniVy+MC+FC+jDig3JaY5WCiryuID8pMz9rvr+qcQtlT84oNlK17FcmGssx9lb+jIF7l8rgMPpSvIQ4ov07McgjR13XEB2WmZ+33N3VOoeyped0Gyta9gWRDWea+wd9REK9yeVwDH8o3EQeU2xGzHEr0dQvxQZnpWfv9XZ1TKHtq3rKBsnVvI9lQlrlv83cUxKtcHjfBh/IdxAHl9sQshxF93UV8UGZ61n7/UOcUyp6ad22gbN17SDaUZe57/B0F8SqXxx3woXwfcUC5AzHL4URfDxAflJmetd8/1TmFsqfmAxsoW/chkg1lmfshf0dBvMrlcR98KD9K+NwPjcajZ+yIAfm8XwGHfCILSOrjMTQamCoxVWqqoalGpuQnassPcJVPcPnxVM1MyZvvy3s9y1uLyjvZyRsnyft0yLeFy3chyje9yNdYy5f0yVeQyD9Yyt+Py1/HtDfVAU8//gPtkm0+xbkAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha256/target/witness.tr b/crates/nargo_cli/tests/test_data/sha256/target/witness.tr index e0cd7de22c6..e0ab1a7e37f 100644 Binary files a/crates/nargo_cli/tests/test_data/sha256/target/witness.tr and b/crates/nargo_cli/tests/test_data/sha256/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/sha2_blocks/target/main.json b/crates/nargo_cli/tests/test_data/sha2_blocks/target/main.json deleted file mode 100644 index d91ddbcca35..00000000000 --- a/crates/nargo_cli/tests/test_data/sha2_blocks/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result256","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result512","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result256":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35],"result512":[36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99],"x":[1,2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha2_blocks/target/sha2_blocks.json b/crates/nargo_cli/tests/test_data/sha2_blocks/target/sha2_blocks.json new file mode 100644 index 00000000000..1c013cc714e --- /dev/null +++ b/crates/nargo_cli/tests/test_data/sha2_blocks/target/sha2_blocks.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":3,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result256","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result512","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result256":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35],"result512":[36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99],"x":[1,2,3]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha2_blocks/target/witness.tr b/crates/nargo_cli/tests/test_data/sha2_blocks/target/witness.tr index b2245408b31..0d52b61c540 100644 Binary files a/crates/nargo_cli/tests/test_data/sha2_blocks/target/witness.tr and b/crates/nargo_cli/tests/test_data/sha2_blocks/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/sha2_byte/target/main.json b/crates/nargo_cli/tests/test_data/sha2_byte/target/main.json deleted file mode 100644 index 7bedae5d2d4..00000000000 --- a/crates/nargo_cli/tests/test_data/sha2_byte/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result256","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result512","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result256":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"result512":[34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha2_byte/target/sha2_byte.json b/crates/nargo_cli/tests/test_data/sha2_byte/target/sha2_byte.json new file mode 100644 index 00000000000..05fa9984dfb --- /dev/null +++ b/crates/nargo_cli/tests/test_data/sha2_byte/target/sha2_byte.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"result256","type":{"kind":"array","length":32,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"result512","type":{"kind":"array","length":64,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"}],"param_witnesses":{"result256":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"result512":[34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97],"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/sha2_byte/target/witness.tr b/crates/nargo_cli/tests/test_data/sha2_byte/target/witness.tr index 040f1224e20..42967e2d9e0 100644 Binary files a/crates/nargo_cli/tests/test_data/sha2_byte/target/witness.tr and b/crates/nargo_cli/tests/test_data/sha2_byte/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/signed_division/target/main.json b/crates/nargo_cli/tests/test_data/signed_division/target/main.json deleted file mode 100644 index 053213118a5..00000000000 --- a/crates/nargo_cli/tests/test_data/signed_division/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1d/W8TRxB9/iCBhKaQLyclaS4JIRSK2fXZ8bmYfBAKRRXtD1VV0f5QJa1T0Ur9T/o/d1fsHXcHEpLvzWpP8krIZ4m8nX3zbmY8k4v/BfAf3q2G+dd0r1HufbP0vuXep/8XuZ+369S9qmpLN3lYCqVVFTdxr22Dca3EA5WElPS22yR9bzfdKe3ZEnRArI76/cmwN9GxvlC90WUyUP3B5VGiEz1IBn/2kjieJP1kOLocDdVI9+OJvhqM4qHDahOwrpxh13hnVNIibiB8Ec8ZjHl4EPFcScTzHkTcIIp4jijieXCFURbutPZNrt6thvOXpD/UdEunF0x/XA/cH2kSkAzyarqV+YMZ5G+gPkGerR0JG5l8LhiMRXhIGHajHbxPGIuQTxg3iCJeJGLdJGKlfN7M8SkhuAXwAmFq+/fg32wSOmL6/jOiXVL8Ncn8XQ+TP5HkbhOnRLHVJmIxi62lwP1h49YS+LHrNfzErqp2toi6WSDa9QOCjv1ZIUzUt35N5O/HmujvcyJ/RM1oJn+Wsw8KaPDrMCKXKm/vrdx12702P6KJOYEzobRPmcclCH44kXLSLQHc2+DdlFLnvs33USE4hczppzoTjA96Fc+dJTWUFgt32WCswEM3YRnF9rPdNCrtyc5khPZzz2HpZaJdK0QHSou4hfBFvGow1uBBxKslEa95EHGLKOJVol1rNRIxs88OIRGvG4wOPIh4vSTijgcRE6bZmYjXiXZ1BEXcFPAfC2uFhyV2Q2wYjE14uCE2ULwh7KZRac8AJ7EZVt6ZVW+InyAjDFJAyYLABvHMm0RfMPnz1aQgnr/QpPgidz1rUlTE3HSEsnHvIOwmhT33Hb6PRJsUTE6lqwrmtGEN4VcVWwZjGx6qii0Uqwq7aVTak11VSDmzqoh/Rj2qii3imbeJvmDy56uqIJ6/UFV8mbueVRUVMbcdoWzcHYRdVdhz7/B9JFpVMDn9VMNNVVu1eHwkMhi78FAJRChWAruo1+MjEVF4u7wzios44CZZJuI9g7EPDyLeK4l434OIGY2tVMR7RBHvgysM9m/QrTh/SfpDTbeyz2FMf9wN3B9pEgj58ZGI6I8D1CfIs7UjYSOTz3sG4xAeEobdKP/4yCHkE8YBUcSHRKz7RKyUz/uQe3zkwPmPPYf/BfybTUJHTN9/RbRLir8mmb+7YfInktwjyBRbERGLWWw9CNwfNm49AD92vYGf2BXA72WlS98j2vUrgo79WSFM1Ld+Q+Tvt5ro7yGRP6JmNJM/XzMUIpeFGcrXuevZDKUi5kNHKBv3EcKeodhzP+L7SHSGwuRUujPRgQynDBvT9nPXYDyGh25CF8X2s91UupvQIYglbT93icJ7zDvjbIbigDU8iFiVRKxRrxmKIopYgysMiRmKQtgzFKY/eoH7wwbjLmSDvJpuZf5gBvkY9QnybO1I2Mjks28wBvCQMOxG+RnKAPIJIyaKeEDEOiJipXweQW6GEjv/sfuQv4N/s0noiOn7IdEuKf6aZP56YfInktxt4pQotrpELGaxlQTuDxu3EvBj1wX8xK6Q/gRXn2jXJYKO/VkhTNS3viDy90dN9Dci8kfUjGby52uGQuSyMEP5Jnc9m6FUxBw5Qtm4TxD2DMWe+wnfR6IzFCansxmKUmOD8RQeugljFNvPdtM6zVDGROE95Z1x9jUmZh0bjBN4EPFxScQnqNfXmBwTRXwCrjDYHyMbzl8hf40J0x+ngfvDBuMxwp6hMIP8GeoT5NnakbCRyeczg3EODwnDbpSfoZxDPmGcEUV8TsR6TsRK+XwOuRnKmfMfuw/5F/g3m4SOmL7/lmiXFH9NMn+nYfInktxt4pQotsZELGax9SJwf9i49QL82PUWfmJXSM+hPCPa9TeCjv1ZIUzUt35L5O+fmujvJZE/omY0kz9fMxQil4UZyne569kMpSLmS0coG/cVwp6h2HO/4vtIdIbC5LSVs9HePC18uP4HfLC9I2t+AAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/signed_division/target/signed_division.json b/crates/nargo_cli/tests/test_data/signed_division/target/signed_division.json new file mode 100644 index 00000000000..aee1297d09d --- /dev/null +++ b/crates/nargo_cli/tests/test_data/signed_division/target/signed_division.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"},{"name":"y","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"},{"name":"z","type":{"kind":"integer","sign":"signed","width":32},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2],"z":[3]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/signed_division/target/witness.tr b/crates/nargo_cli/tests/test_data/signed_division/target/witness.tr index 507ca9ecf6f..dc3e7aee633 100644 Binary files a/crates/nargo_cli/tests/test_data/signed_division/target/witness.tr and b/crates/nargo_cli/tests/test_data/signed_division/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/simple_add_and_ret_arr/target/main.json b/crates/nargo_cli/tests/test_data/simple_add_and_ret_arr/target/simple_add_and_ret_arr.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_add_and_ret_arr/target/main.json rename to crates/nargo_cli/tests/test_data/simple_add_and_ret_arr/target/simple_add_and_ret_arr.json diff --git a/crates/nargo_cli/tests/test_data/simple_array_param/target/main.json b/crates/nargo_cli/tests/test_data/simple_array_param/target/simple_array_param.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_array_param/target/main.json rename to crates/nargo_cli/tests/test_data/simple_array_param/target/simple_array_param.json diff --git a/crates/nargo_cli/tests/test_data/simple_bitwise/target/main.json b/crates/nargo_cli/tests/test_data/simple_bitwise/target/main.json deleted file mode 100644 index a7bae86b5a2..00000000000 --- a/crates/nargo_cli/tests/test_data/simple_bitwise/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"boolean"},"visibility":"private"},{"name":"b","type":{"kind":"boolean"},"visibility":"private"},{"name":"c","type":{"kind":"integer","sign":"unsigned","width":8},"visibility":"private"},{"name":"d","type":{"kind":"integer","sign":"unsigned","width":8},"visibility":"private"}],"param_witnesses":{"a":[1],"b":[2],"c":[3],"d":[4]},"return_type":{"kind":"integer","sign":"unsigned","width":8},"return_witnesses":[22]},"bytecode":"H4sIAAAAAAAA/9VYW2rDMBDcOM771TwpaT9KaemvFNuJ/NerNNS6/xEqEQsklRKoRsZeMELYGWlntLOx34nog27RU1dSjz1rnnjzvrrG1jy15uQ9q8eBh2nfG1q/M7gGb2Q9798bkxtJPX7WY8bOeV5dThXP+Bc7lVdRsLy4ngUXvBDF90lkWSVycSmv5YWVPM8qLosyk+wWfSDWxMJiQSFlzJxTINYUmLM5H5Na92k9zqxz9BcnLCz4AIg1xGEx8gKCyxmbK4yFxymUUFP8c3LNYEG/i7rfETFDi+WR4hwMn7//7rOSOhifA3NeALVA8mc3OwLmazdPdD2hsBIgFlDfaGa3VBgrasDsluSanV7UmF2sg4bGPVIzJsXCIlpBhPL31BH+kMZ8BPL3TO1ukmafD0D+gGeGt50/8ydjCdRiBeQPqCuL/dYyAmIBOYzWyNcKY0MNNPI1uY1cLxr7rSWWmKHF9ULdMJQ1MOcNUAskf7ENZQzEAnIYzVC2CmNHDRjKllxD0YvGNpRYYoYW1yt1w1C2wJx3QC2Q/N0zlNC8Z8C8cRy639dhNacMZa8wDtSAoezJNRS96D1DaauYoft6o24Yyh6Y8wGoBY4/KdMax/4OmlqcmsLQ+/8B0bvyaJUcAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_bitwise/target/simple_bitwise.json b/crates/nargo_cli/tests/test_data/simple_bitwise/target/simple_bitwise.json new file mode 100644 index 00000000000..254392638c4 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/simple_bitwise/target/simple_bitwise.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"a","type":{"kind":"boolean"},"visibility":"private"},{"name":"b","type":{"kind":"boolean"},"visibility":"private"},{"name":"c","type":{"kind":"integer","sign":"unsigned","width":8},"visibility":"private"},{"name":"d","type":{"kind":"integer","sign":"unsigned","width":8},"visibility":"private"}],"param_witnesses":{"a":[1],"b":[2],"c":[3],"d":[4]},"return_type":{"kind":"integer","sign":"unsigned","width":8},"return_witnesses":[20]},"bytecode":"H4sIAAAAAAAA/+1ZbW+CMBA+UBFQ8TUu2fZhWbZ9bgUUvu2vzAz+/0+YjWU5GheX9IGI4RJyabUPveeufS7hnYg+6GzO6XG1d9jYNcaD0+Oz8ZCNzbXKj7QntrZa47H/m7+NqW6u9p/ax2KfJMVhV8hYfoldfsxSkaTHfSYzmWbp9y6L4yJLskN+zA8il0lcyDLN41KcbQDE8hmWsLKybDLmIRArAMZc1Yevn0D7UNfFgHHiGJwIO5O8VpG4IxyWoAsGwZYNYp/QXYY50X7K5gLtq3tGmcfyXOVd1W3I1jnMOwwjZGsu/cf5Aydgc9X6iO2FcJwIj+C1JiKGid7w7wGZUP1yV4n0DSLR7zRxbS+tLTVzKAfg+EeAmItSmZATIH8PLfFnu88pMBfAmpFI/q4Joy2HvOFD1rZDWIFBYQFr5i4Ee6Z9xOZ6wcZgtiLYM6oLtnqpb7yzK4fb9jJ7pHaES9hZ7RKyFf4ZkL8n6obwR0CsLRDruSP1BzwnElgzEsmf2ThV5oK59IBYEfXNCW9O5tov2FzfnGAwW2lO5lRvTlQim25OmjqQtuLwQrctrlVDMQfGvADmAslfW+IwBmIBubwLcVhqv2JzvThgMFsRhyXVxUElsmlxaOpA2l6Ur9QNcVgCY14Bc4Hk77/iYBt/CIwfx2X92zQZMQsba1Ec1tpv2FwvDhjMVsRhTXVxUIm8Jg63eiBt9/VG3RCHNTDmDTAXOP7Kcqhx+HezIeO0Ohhq/z8o2eODeSUAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_bitwise/target/witness.tr b/crates/nargo_cli/tests/test_data/simple_bitwise/target/witness.tr index 52fe05628fb..64d564557c8 100644 Binary files a/crates/nargo_cli/tests/test_data/simple_bitwise/target/witness.tr and b/crates/nargo_cli/tests/test_data/simple_bitwise/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/simple_comparison/target/main.json b/crates/nargo_cli/tests/test_data/simple_comparison/target/main.json deleted file mode 100644 index dcbf9a8cb95..00000000000 --- a/crates/nargo_cli/tests/test_data/simple_comparison/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/81UWw6DIBBc8YFpk57BI7A8FP56lZrisXuWYoq2If1jMU5CgJ+Z7OzsXgHgBh+wcCr4Ynvf4y3ygBUdl4AEmby4PerA0SQ+kJuwGr0KvaIQi6JDolkXbIASo9Z+kh4VPoR0szVCm3m0aNFY85RWKW+1ndzsJuFQK4+LcXKJXHU+l4pcoqGrUZQOMYPzh7gNHB0cEOI2CXF3QIgZYYhbwhB3UC7EjNjD5lx178EF2rzuvDxw9HDAQPAosv1X0SHRpB6IUs3M5bpAmU2Z+pe7BDhhzT1hXwn8+ztYFY1/e80caBcf/MxPijdUC8hSrwoAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_comparison/target/simple_comparison.json b/crates/nargo_cli/tests/test_data/simple_comparison/target/simple_comparison.json new file mode 100644 index 00000000000..3e7da053a47 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/simple_comparison/target/simple_comparison.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2UbW6DMAyGTaDQbhJnQD2BQ0hJ/u0qQ6PH3lU2ZTPIYtBpioP2A0vIgJLXX8nzDAA1fFtOz9Iy8i/kMc50JqeFK+nGauuE2nMMxTSnnhfs34W8oidYyebB93zAz1ll7F3RmvzBmmxD57KSZ81yAbmeYAniZw1rpimd8NdBVtSYdwqkaCjNImaeIPakZfDWdWPfjtroV2z94Cx2drg57bR19q11xoyuc70ffI9ed2bUd+vbO2nl8VqGtLCQqxH3ApKCA0gcSCfy/JIfQJLR3AVIYYAcSKGQZhFTGkj8EsUC6QRyQCohPZCUcC+L/1V/SgDtDreK/Jn9+wvcrmzfFtyu8Dvc1nQOuG3bDLeKNTN8h0E2i5jScEt1IWO1nuRqxEf9iwV6JVjzWXCuAv1bBVgm07+55kpwzorlyME42ScdpGNiExAAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_mut/target/main.json b/crates/nargo_cli/tests/test_data/simple_mut/target/simple_mut.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_mut/target/main.json rename to crates/nargo_cli/tests/test_data/simple_mut/target/simple_mut.json diff --git a/crates/nargo_cli/tests/test_data/simple_not/target/main.json b/crates/nargo_cli/tests/test_data/simple_not/target/simple_not.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_not/target/main.json rename to crates/nargo_cli/tests/test_data/simple_not/target/simple_not.json diff --git a/crates/nargo_cli/tests/test_data/simple_print/target/main.json b/crates/nargo_cli/tests/test_data/simple_print/target/main.json deleted file mode 100644 index a34f39ce9c1..00000000000 --- a/crates/nargo_cli/tests/test_data/simple_print/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2b24rbMBCGnd3G8ikn55ynyKGV27u8R696uiiUpZS+P13ZFkwTUQ10RoyJBIuzSZj//yzHsn9Lz0mSPCVde379GyX3zb537bfH/2unEV2t463Xj/02B1y2peD1lUg/pd8/x/FrjXFfa9r7fkOqcTrmfX+7+vl2HyVAPwXeaLx0+zAlrdl8NjUU8G9ZrfcSfJ6CraJla4/1cfL3PrX/Kzbd89nUyDz8mcNHFpA/Y9PVbf/nHv7c4SMPyJ+z6eoPpkbh4S8cPoqA/AWbrv5mGf/FXzp8lAH5SzZd/dbUqDz8lcNHFZC/Aroc5z8svxLAT6t7+WRqTDz8E4ePSUD+CdDl6H8svxLAT6urtakx9fBPHT6mAfmnQJdj/MPy5wL4aXX1O1Nj5uGfOXzMAvLP2HT1F1Nj7uGfO3zMA/LPgS7H+I/lLwXwc5z/sfxKAD+tbvPV1Fh4+BcOH4uA/FYrA33w89f3l98/XuzXYYRjX48ADuzCu+jqSsQAc7FRcp8rDSEfo/b4xODRtqI3GyjDOw8zw7tcYoYXM7yY4d37iBkepY+Y4cUML2Z4McNz88cMj0tXn0yNIWV4tLpN2/9DyrAenZ/j+MfyTwTw0+o27fXfkDLMmOGR8rcZ9lAyPK7+x/IrAfy0ut0zjNrDXzt81AH5azbd7hnW0sO/dPhYBuRfAl2O+18sfyGAn1ZXN6bGysO/cvhYBeRfsek27f3/2sO/dvhYB+Rfs+nq96bGxsO/cfjYBOTfAF2O8Q/LrwTwc+QfWP5KAD+t7qXt/62Hf+vwsQ3IvwW6HNe/WP65AH6O3z+WXwng5xj/sPwrAfwc9/9Y/pkAflrdpp0XsPPw7xw+dgH5d0CX4/4Hy18L4Oc4/2H5lQB+jusfLH8lgJ9j/geWPxXA/+jHP8f8Dyx/JoCfY/4Hlj8XwM+Rf2H5CwH8HPM/sPylAP44/lPqDm/8f/T+p9Xt1nDtPfx7h499QP490OUY/7D8uQB+jvs/LH8tgJ/j+SeWfyGAn2P8x/KXAvg5zv9YfiWAn1a3W8N18PAfHD4OAfkPkb9tiDVscOkYfM9iXfot61o2uI5tdGPGtD8iE2puEEoAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_print/target/simple_print.json b/crates/nargo_cli/tests/test_data/simple_print/target/simple_print.json new file mode 100644 index 00000000000..b4fa7657e77 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/simple_print/target/simple_print.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2b24rbMBCGnWxjxYecnHOeIodWbu/yIL3p6aJQllL6/nRlW2WaiGpgZ8SYSLBk14H5/0/yWtZv6ylJkmHStqeXn0Fy3+yxa/d5fF07DehqHW+9fuw+M8BlWwp+vxLpp/T9cxy91Bh1taad7zekGqdj1o23a5xv+ygB+inwRuOl7cOUtGb92dRQwL9ltd4L8H0KPhUtW3Ouj5J/+9T+rdh0z2dTY+zhHzt8jAPyj9l0dTP+mYc/c/jIAvJnbLr6g6mRe/hzh488IH/Opqu/Wcb/8RcOH0VA/oJNV781NUoPf+nwUQbkL4Eux/UPy68E8NPqXj6ZGhMP/8ThYxKQfwJ0OcYfy68E8NPqam1qTD38U4ePaUD+KdDlmP+w/JkAflpd/c7UmHn4Zw4fs4D8MzZd/cXUmHv45w4f84D8c6DLMf9j+QsB/BzXfyy/EsBPq1t/NTUWHv6Fw8ciIP8C6FJnCmZNZ8f156/vz79/PN92hWk2IhqA4/C0gUv1u2jsStRHMHcbJPe5VR/yN2qPQwaPthWd2UAZ4bmfGeHlEjPCmBHGjPDeR8wIKX3EjDBmhDEjjBmhmz9mhFy6+mRq9CkjpNWtm/HvU0b26Pwc5z+WfyKAn1a3bu7/+pSRxoyQlL/JyPuUEXKMP5ZfCeCn1W2fkVQe/srhowrIX7Hpts/Ilh7+pcPHMiD/EuhyrH+x/LkAflpdXZsaKw//yuFjFZB/xaZbN+v/tYd/7fCxDsi/ZtPV702NjYd/4/CxCci/Aboc8x+WXwng58g/sPylAH5a3Usz/lsP/9bhYxuQfwt0Oe5/sfxzAfwc//9YfiWAn2P+w/KvBPBzrP+x/DMB/LS6dfNewM7Dv3P42AXk3wFdjvUPlr8SwM9x/cPyKwH8HPc/WP5SAD/H+x9Y/lQA/6Of/xzvf2D5xwL4Od7/wPJnAvg58i8sfy6An+P9Dyx/IYA/zv+Uuv2b/x99/Gl12z1iew//3uFjH5B/D3Q55j8sfyaAn2P9h+WvBPBzPP/E8i8E8HPM/1j+QgA/x/Ufy68E8NPqtnvEDh7+g8PHISD/IfL/1R3R6mL2yMHtaENwzH5/AbatPda9cnCf3ODGmGl/ABUi7knQSgAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_program_addition/target/main.json b/crates/nargo_cli/tests/test_data/simple_program_addition/target/simple_program_addition.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_program_addition/target/main.json rename to crates/nargo_cli/tests/test_data/simple_program_addition/target/simple_program_addition.json diff --git a/crates/nargo_cli/tests/test_data/simple_program_no_body/target/main.json b/crates/nargo_cli/tests/test_data/simple_program_no_body/target/simple_program_no_body.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_program_no_body/target/main.json rename to crates/nargo_cli/tests/test_data/simple_program_no_body/target/simple_program_no_body.json diff --git a/crates/nargo_cli/tests/test_data/simple_radix/target/main.json b/crates/nargo_cli/tests/test_data/simple_radix/target/simple_radix.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_radix/target/main.json rename to crates/nargo_cli/tests/test_data/simple_radix/target/simple_radix.json diff --git a/crates/nargo_cli/tests/test_data/simple_range/target/main.json b/crates/nargo_cli/tests/test_data/simple_range/target/simple_range.json similarity index 100% rename from crates/nargo_cli/tests/test_data/simple_range/target/main.json rename to crates/nargo_cli/tests/test_data/simple_range/target/simple_range.json diff --git a/crates/nargo_cli/tests/test_data/simple_shield/target/main.json b/crates/nargo_cli/tests/test_data/simple_shield/target/simple_shield.json similarity index 51% rename from crates/nargo_cli/tests/test_data/simple_shield/target/main.json rename to crates/nargo_cli/tests/test_data/simple_shield/target/simple_shield.json index 963e1ded6ad..08e53fc8eb8 100644 --- a/crates/nargo_cli/tests/test_data/simple_shield/target/main.json +++ b/crates/nargo_cli/tests/test_data/simple_shield/target/simple_shield.json @@ -1 +1 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"priv_key","type":{"kind":"field"},"visibility":"private"},{"name":"note_root","type":{"kind":"field"},"visibility":"public"},{"name":"index","type":{"kind":"field"},"visibility":"private"},{"name":"note_hash_path","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"private"},{"name":"to_pubkey_x","type":{"kind":"field"},"visibility":"private"},{"name":"to_pubkey_y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"index":[3],"note_hash_path":[4,5,6],"note_root":[2],"priv_key":[1],"to_pubkey_x":[7],"to_pubkey_y":[8]},"return_type":{"kind":"array","length":2,"type":{"kind":"field"}},"return_witnesses":[13,15]},"bytecode":"H4sIAAAAAAAA/9Va6UrDQBAeW++7ifd9Kx6QbRKbgILik1hM3/8Jijs6odtQ/GG/gd2BYXNspvt9c+yU5IOIHuhX5qy2RVlm5dq81RmryzIOrS4553y/Jc8syf1lGVlWrK46c9vO9aGcDx3bLGtW1yfYX5A5i87cDaubMqeeR/Isy5uMyXRi2jhbSc1Bx2pkNZa1z8jYkeP6PGqcxw6+WtqKeNPkOcuqXrcyqflMumW/yJMs7z8XpjB5kX91izStiqzolf2yl5QmSyszyMt0IMY6QFv3QD/8xd9/11kNfiXC2fqKgX7V4q8F4k8jZraA/IWCeRuMGV1PeX/pTLA7Le5HwsY3Gjfve1sKuJ/I77pYr3MHyCXQ1wbNn0a+bCvETRJAvmjUCUNh5MsukEugrw2Sv2afzzWC+/tdGvX5e1b3aVzQ+28EtHVAYfQcSMyH5HfPwf9nI8LXkoz8rqGcOwcKuHMKo4YeAbkE+tqg+dPIl0OFuCk8x801Yk8Bd0lh5MsxkEugrw2Sv2bPwTWCe41jGvUcJ1ZPaVzQ+28MtHVGYfQcSMzn5HfPwTEWE76WvJDfNZRz50wB9yuFUUMvgFwCfW3Q/Gnky7lC3Lx5jptrxIkC7ncKI18ugVwCfW2Q/DV7Dq4R3Gtc0qjnuLJ6TeOCfrfXAvrtCmjrBofx5x1r8x0pET5vkWt213vrHM/K2JoQE/MKmKjxO00e1ydc87oJuxFC0XbvCBf8Wrjv8D4a2wh85nTBWSMHsvtRC99bdNbvfkDCH6DwhyXfXhqTzyEjAAA=","proving_key":null,"verification_key":null} \ No newline at end of file +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"priv_key","type":{"kind":"field"},"visibility":"private"},{"name":"note_root","type":{"kind":"field"},"visibility":"public"},{"name":"index","type":{"kind":"field"},"visibility":"private"},{"name":"note_hash_path","type":{"kind":"array","length":3,"type":{"kind":"field"}},"visibility":"private"},{"name":"to_pubkey_x","type":{"kind":"field"},"visibility":"private"},{"name":"to_pubkey_y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"index":[3],"note_hash_path":[4,5,6],"note_root":[2],"priv_key":[1],"to_pubkey_x":[7],"to_pubkey_y":[8]},"return_type":{"kind":"array","length":2,"type":{"kind":"field"}},"return_witnesses":[13,15]},"bytecode":"H4sIAAAAAAAA/9Va6UrDQBAeW++7ifd9Kx6QbRKbgILik1hM3/8Jijs6odtQ/GG/gd2BYXNspvt9c+yU5IOIHuhX5mRsyzgr1+atzlhdlnFodck55/steWZJ7i/LyLJiddWZ23auD+V86NhmWbO6PsH+gsxZdOZuWN2UOfU8kmdZ3mRMphPTxtlKag46ViOrsax9RsaOHNfnUeM8dvDV0lbEmybPWVb1upVJzWfSLftFnmR5/7kwhcmL/KtbpGlVZEWv7Je9pDRZWplBXqYDMdYB2roH+uEv/v67zmrwKxHO1lcM9KsWfy0QfxoxswXkLxTM22DM6HrK+0tngt1pcT8SNr7RuHnf21LA/UR+18V6nTtALoG+Nmj+NPJlWyFukgDyRaNOGAojX3aBXAJ9bZD8Nft8rhHc3+/SqM/fs7pP44LefyOgrQMKo+dAYj4kv3sO/j8bEb6WZOR3DeXcOVDAnVMYNfQIyCXQ1wbNn0a+HCrETeE5bq4Rewq4SwojX46BXAJ9bZD8NXsOrhHcaxzTqOc4sXpK44Lef2OgrTMKo+dAYj4nv3sOjrGY8LXkhfyuoZw7Zwq4XymMGnoB5BLoa4PmTyNfzhXi5s1z3FwjThRwv1MY+XIJ5BLoa4Pkr9lzcI3gXuOSRj3HldVrGhf0u70W0G9XQFs3OIw/71ib70iJ8HmLXLO73lvneFbG1oSYmFfARI3fafK4PuGa103YjRCKtntHuODXwn2H99HYRuAzpwvOGjmQ3Y9a+N6is373AxL+AIU/LPkGuNQmbyEjAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/main.json b/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/main.json deleted file mode 100644 index 96caf4b87da..00000000000 --- a/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/9WWOw7CMAyG3QflJTEwMTBwBLtJaLJxFSrS+x+BBlIpjZjARmApSqpKfvz+5GQLAHt4WjGuMu6n5AzJ/2CXuONnRgWfL4TMePwSBg2qTAd2Ecq4jkkTQtA6i1kJNkDhWWvftZ4UXbF1vTWoTX+2ZMlYc2utUt5q27nedehIK0+DccoPD6OSwdcQE6v4akRZiAl/GGKaDoGjBXwB4jqu6TsEPYEkxPMGvAleG8GjmhHiBfwLxEicuYIEYyPKzehjCV+AOAQ6JBCHoCuQhHjegM8mMVLDCPESZMDg1o/z9uHUb8Wo38tnCPAPA86c03zXyXl62ZQvmGgEaoIsTq7jDgQHi1ST1gJ+N8AHv1TdG/4ezYbTL2taZDmmdgfT0ibxzA0AAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/simple_shift_left_right.json b/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/simple_shift_left_right.json new file mode 100644 index 00000000000..384946facdb --- /dev/null +++ b/crates/nargo_cli/tests/test_data/simple_shift_left_right/target/simple_shift_left_right.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"param_witnesses":{"x":[1]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2WzW6DMAzHHWhp6aQedtphh+7Qu02ghNteZWjw/o8w6JLWDXTThoNaqZGs0JD+Y/zxU54A4Bm+h+ossvOus9iaP5Sd3+2M0wYpOS0ccVdImwJqI0VM0z3z2KfsnXufsHy4vYvO3mCYK8WeI7sn/mGPuqKTsjX3/y3zBeRiggmI1xpumaa0w+QaqLdXODdUbBMDI8GTPNtpaTzkeVNmDWn6wKyqTYF5UR8MGSpM8ZkZrRuTm7KqqxIrynVDbVHppj2OYzFO1WqtY7HcN+I8QCK8cSBRQO3TGRxIrnaXbO0vQNrDMFc+kPbwO5DGdB5Auj5OQFpYc7/7RO68M2WBdNlE/4RIZiFCC5AD0hLuDUhIkj6PuCujTfMByTX3iq09bkgymrMAqXf8Bc5A6hO59s6UviHxJpp2Q0JKQA5IKwjT3NLxk7wVSsZvDbJAHxQ/yANd0mfuL4ePu7VFIzURABwE3jl+HIOCJVSS0gC6G5Ar/lDfvZHP0QWcbjmmyvORjy+tS+RfMBMAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/slices/src/main.nr b/crates/nargo_cli/tests/test_data/slices/src/main.nr index a0460aafb40..cda6657b4ff 100644 --- a/crates/nargo_cli/tests/test_data/slices/src/main.nr +++ b/crates/nargo_cli/tests/test_data/slices/src/main.nr @@ -4,7 +4,7 @@ fn main(x : Field, y : pub Field) { /// TODO(#1889): Using slices in if statements where the condition is a witness /// is not yet supported - let mut slice: [Field] = [0; 2]; + let mut slice = [0; 2]; assert(slice[0] == 0); assert(slice[0] != 1); slice[0] = x; @@ -15,7 +15,7 @@ fn main(x : Field, y : pub Field) { assert(slice_plus_10[2] != 8); assert(slice_plus_10.len() == 3); - let mut new_slice: [Field] = []; + let mut new_slice = []; for i in 0..5 { new_slice = new_slice.push_back(i); } @@ -42,5 +42,39 @@ fn main(x : Field, y : pub Field) { assert(removed_elem == 2); assert(remove_slice[3] == 3); assert(remove_slice.len() == 4); + + regression_2083(); } +// Ensure that slices of struct/tuple values work. +fn regression_2083() { + let y = [(1, 2)]; + let y = y.push_back((3, 4)); // [(1, 2), (3, 4)] + let y = y.push_back((5, 6)); // [(1, 2), (3, 4), (5, 6)] + assert(y[2].1 == 6); + + let y = y.push_front((10, 11)); // [(10, 11), (1, 2), (3, 4), (5, 6)] + let y = y.push_front((12, 13)); // [(12, 13), (10, 11), (1, 2), (3, 4), (5, 6)] + + assert(y[1].0 == 10); + + let y = y.insert(1, (55, 56)); // [(12, 13), (55, 56), (10, 11), (1, 2), (3, 4), (5, 6)] + assert(y[0].1 == 13); + assert(y[1].1 == 56); + assert(y[2].0 == 10); + + let (y, x) = y.remove(2); // [(12, 13), (55, 56), (1, 2), (3, 4), (5, 6)] + assert(y[2].0 == 1); + assert(x.0 == 10); + assert(x.1 == 11); + + let (x, y) = y.pop_front(); // [(55, 56), (1, 2), (3, 4), (5, 6)] + assert(y[0].0 == 55); + assert(x.0 == 12); + assert(x.1 == 13); + + let (y, x) = y.pop_back(); // [(55, 56), (1, 2), (3, 4)] + assert(y.len() == 3); + assert(x.0 == 5); + assert(x.1 == 6); +} diff --git a/crates/nargo_cli/tests/test_data/slices/target/main.json b/crates/nargo_cli/tests/test_data/slices/target/slices.json similarity index 100% rename from crates/nargo_cli/tests/test_data/slices/target/main.json rename to crates/nargo_cli/tests/test_data/slices/target/slices.json diff --git a/crates/nargo_cli/tests/test_data/strings/src/main.nr b/crates/nargo_cli/tests/test_data/strings/src/main.nr index bee2370201c..9f122c3a137 100644 --- a/crates/nargo_cli/tests/test_data/strings/src/main.nr +++ b/crates/nargo_cli/tests/test_data/strings/src/main.nr @@ -1,10 +1,13 @@ use dep::std; +// Test global string literals +global HELLO_WORLD = "hello world"; + fn main(message : pub str<11>, y : Field, hex_as_string : str<4>, hex_as_field : Field) { let mut bad_message = "hello world"; assert(message == "hello world"); - bad_message = "helld world"; + assert(message == HELLO_WORLD); let x = 10; let z = x * 5; std::println(10); @@ -16,6 +19,7 @@ fn main(message : pub str<11>, y : Field, hex_as_string : str<4>, hex_as_field : assert(y == 5); // Change to y != 5 to see how the later print statements are not called std::println(array); + bad_message = "helld world"; std::println(bad_message); assert(message != bad_message); @@ -39,9 +43,8 @@ fn test_prints_strings() { fn test_prints_array() { let array = [1, 2, 3, 5, 8]; - // TODO: Printing structs currently not supported - // let s = Test { a: 1, b: 2, c: [3, 4] }; - // std::println(s); + let s = Test { a: 1, b: 2, c: [3, 4] }; + std::println(s); std::println(array); @@ -49,6 +52,21 @@ fn test_prints_array() { std::println(hash); } +fn failed_constraint(hex_as_field: Field) { + // TODO(#2116): Note that `println` will not work if a failed constraint can be + // evaluated at compile time. + // When this method is called from a test method or with constant values + // a `Failed constraint` compile error will be caught before this `println` + // is executed as the input will be a constant. + std::println(hex_as_field); + assert(hex_as_field != 0x41); +} + +#[test] +fn test_failed_constraint() { + failed_constraint(0x41); +} + struct Test { a: Field, b: Field, diff --git a/crates/nargo_cli/tests/test_data/strings/target/main.json b/crates/nargo_cli/tests/test_data/strings/target/main.json deleted file mode 100644 index a1c7b8ec6e7..00000000000 --- a/crates/nargo_cli/tests/test_data/strings/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"string","length":11},"visibility":"public"},{"name":"y","type":{"kind":"field"},"visibility":"private"},{"name":"hex_as_string","type":{"kind":"string","length":4},"visibility":"private"},{"name":"hex_as_field","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"hex_as_field":[17],"hex_as_string":[13,14,15,16],"message":[1,2,3,4,5,6,7,8,9,10,11],"y":[12]},"return_type":null,"return_witnesses":[]},"bytecode":"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","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/strings/target/strings.json b/crates/nargo_cli/tests/test_data/strings/target/strings.json new file mode 100644 index 00000000000..0b2d57ec3b3 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/strings/target/strings.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"message","type":{"kind":"string","length":11},"visibility":"public"},{"name":"y","type":{"kind":"field"},"visibility":"private"},{"name":"hex_as_string","type":{"kind":"string","length":4},"visibility":"private"},{"name":"hex_as_field","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"hex_as_field":[17],"hex_as_string":[13,14,15,16],"message":[1,2,3,4,5,6,7,8,9,10,11],"y":[12]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+2di3cbxRXGb+zYsiS/Y8cPngUKFCjoYUsyUF4FChQoUKBAgWLHdklJwxsKFFJIIYUUUiikpAmQQkr/pf41Pc2sRnS82WQn3e9O7sR3z8nRyM757v3mrn+rndkZ/YuI/k3dY8vxf332dch535d63596vzX1fiD1fjD1vpR6P5R6X069r6TeV+37AZt3NZV/v81pwMbuxStbrarzf0dS2qOp92Op9+NO7C02DlmdUfv/x2nj0Wdfb7KvtWJHfYuj1ay1FhbW2o21erO+XGssrXQWawuLK61OvVNf7CyuNjrN5lpnodNeWllq15bqC821+vriUnPdik0CtNbWzbG01G/7JH1sAfufxGnV3Hy3Oe2tqdqZo9++DjJ4olScdD+OZvwMGpyjSNsYdKcId/Jz+Z7C16jmSMKB0gfs02mCAWVHKKBMEw9QtjttBUpBzWnboWjdGZINFON7Bl8jVqD0A/t0lmBAWQwFlFniAcqc01agFNSctR2K1p0n2UAxvufxNWLJ1XySmsnQLdqv51AcIN0K9HwuxQfSc4kHpOc5bQVpQc1zbYeidc8n2SA1vs/H14glVwP8cwgP0gsoDpAOAD1fSDCQNkKB9ELiAen3nLaCtKDmhbZD0boXkWyQGt8X4WvEkqsB/gWEB+nFFAdIB4GeLyEUSNfqoUB6CfGA9PtOW0FaUPMS26Fo3UtJNkiN70vxNWLJ1QD/YsKD9DKKA6QloOfLCQXSznIokF5OPCD9gdNWkBbUvNx2KFr3CpINUuP7CnyNWHI1wL+M8CC9kuIA6RDQ81WEAmm4W/uriAekP3TaCtKCmlfZDkXrXk2yQWp8X42vEUuuBvhXEh6k11AcIC0DPdcIBdLOeiiQ1ogHpC7NFKQFNWu2Q9G6DZINUiPawNeIJVcD/GsID9ImxQHSCtDzAqFAGm7WfoF4QLrotBWkBTUXbIeidVskG6TGdwtfI5ZcDfCbhAdpm+IAaRXouUMwkK6GAmmHeEC65LQVpAU1O7ZD0brXkmyQGt/X4mvEkqsBfpvwIL1OuG9Tn+syaoQ4n3oHGvrI5Y3XEwz6wZY3Xk880P+R01boF9S83nYoWvcGkg194/sGfI2iWd54I8GAEmx5443EA5SbnLYCpaBmr0ho3ZtJNlCM75vxNYpmeeMtBANKsPG9W4gHKD922gqUgpq32A5F695KsoFifN+KrxFLruaT1M2Evy29jeIAKXJ54+0UH0hvJx6Q/sRpK0gLat5uOxStewfJBqnxfQe+Riy5GuDfRniQ3klxgBS5vPEugoE02DOQdxEPSH/qtBWkBTXvsh2K1r2bZIPU+L4bXyOWXA3w7yQ8SO+hOECKXN54L6FAGm55473EA9KfOW0FaUHNe22HonXvI9kgNb7vw9eIJVcD/HsID9L7KQ6QIpc3PkAokIZb3vgA8YD0505bQVpQ8wHboWjdB0k2SI3vB/E1YsnVAP9+woP0IYoDpMjljQ8TCqThbu0fJh6Q/sJpK0gLaj5sOxSt+wjJBqnx/Qi+Riy5GuA/RHiQPkpxgBS5vPExQoE03PLGx4gHpL902grSgpqP2Q5F6z5OskFqfD+OrxFLrgb4jxIepE9QHCBFLm98klAgDTdr/yTxgPRXTltBWlDzSduhaN2nSDZIje+n8DViydUA/wnCg3SZ4gApcnnjCsFAGmx54wrxgHSH01aQFtRcsR2K1l0l2SA1vlfxNWLJ9anjGsuEB+macN+mPmsZNSrq+2QABJ8Ly2nd3h2QGaroS/1uEB+/xgDAmnkUrffNnKM2763QGPWa6Z/+VP9sOUmNyIk/6OSGyaXbh4NQzbZBT/Ktpb2j59X9xtOS46n3WsJ6S5biDtDGPu29L7HFbST7HA3l+B/KyGMooP8htritpP7lHP/ljDzKAf2X2eK2ku0pKjn+Kxl5VAL6r7DFba31PJ7KfzUjj2pA/1W2uC2zRQ8N5/gfzshjOKD/YScuB/98/ZcE+MfGbSafi0Zy/I9k5DES0P+IE5ej/r7+SwL8Y+O2ku25RnP8j2bkMRrQ/6gTl+P65+u/LMA/Nm4r2edvLMf/WEYeYwH9j7HFbSXjV+M5/scz8hgP6H/cictx/ff1XxXgn4P/vv5LAvxj47aTYbeJHP8TGXlMBPQ/4cRFjymYe7peXZ97Yeful3btTneFOXpDRFucn7unjXurzjbmHGasrNlI6+pYmc+hY2U6VqZjZTpWdmIeOlaGzEPHynSsTMfKdKws37+OlUH961gZ6ViZjpX5+dexsjPvX8fKoHF1rOzEQ58r+78OHSvTsTIdK9OxshPz0LEyZB46VqZjZTpWpmNl+f51rAzqX8fKSMfKdKzMz7+OlZ15/zpWBo0b1VgZZSSE0h52tIquFV0HaHUX3q8H+0a4dZzWhoX3v3bauvC+oOa67VC07tOEO/m5fD+Nr1HNkRTdp+7Jm75QEL5f6ky6DSbdJpPuIpNuJ61btcUNNBmzGOdkTLOpkzE6GaOTMSfmoZMxyDx0MkYnY3QyRidjsv3rZAxX3FZy3xHTZAw2bjupf0yTEZvdP8f57+t/RIB/bNx28vkvpskonYyB+k8mI2OajOGov6//kgD/2LjdyejJHP+TGXlMBvQ/yRa3+zDCthz/2zLy2BbQ/zYnLsf9r6//igD/2LitttGYyvE/lZHHVED/U2xx28n9/3SO/+mMPKYD+p9mi9tK5gW25/jfnpHH9oD+tztxOa5/vv5LAvxzjH/4+h8W4B8bt5lc/2Zy/M9k5DET0P+ME5fj86+v/3EB/jn+/n39lwT457j++fqfEuCf4/7f1/+YAP/YuO3keZTZHP+zGXnMBvQ/68TluP/x9T8pwD8H/3z9lwT45/j84+t/WIB/juc/fP0PCvC/2c9/juc/fP0PCfDP8fyHr/+yAP8c41++/isC/HM8/+HrvyrAv17/kXHju/5v9vpj43YX487l+J/LyGMuoP85Jy7H9c/Xf1mAf477P1//kwL8c8x/+vqfEOCf4/rv678qwD8H/339lwT4x8btLsadz/E/n5HHfED/8+r/u7gD2Lg+i5FNan2pbnEXJbtrwXq/D7aBn3mtUvaBidedI2bQZVrr1r2mRaS7wKPbqPHotttM/bDOlC/TGtBw58MX9jXQWs2VONdq1ld1raau1dS1mifmoWs1kXnoWk1dq3ly/7pWkyuurtV09fP8n31rNdvJffYmXquZ8G/zbhzZPq21ahLW6nF8/vH1Xxbgn+Pzj6//igD/2LjdtTq6VtHP/9m3VrER3VpFjvr7+i8J8A+eq07qH9NaTfBaxWS+IKa1ihzXP1//FQH+Oa5/vv7HBfjn+Pzv639UgH9s3O48ZExrdTmuf77+SwL8c4z/+PofFuAfG7eZ7NUT01rtze4fG7f7rE5Ma5XP8LM6Vednvd+f56Qd5FkdV7OPoQ49raL7fe8EaHW/QGBpqZ/CfIHATpzWhi8Q+I3T1i8QKKi503YoWvcZwp38XL6fwddow0NdaKD0Aft0F8GAEuwbSXYRD1B+67QVKAU1d9kORevuJtlAMb5342vECpR+YJ8+SzCgLIYCyrPEA5TnnLYCpaDms7ZD0brPk2ygGN/P42vEkqv5JLU7Q7dov75AcYB0K9DzixQfSF8kHpC+5LQVpAU1X7QditZ9mWSD1Ph+GV8jllwN8F8gPEhfoThAOgD0/CrBQLoaCqSvEg9If+e0FaQFNV+1HYrWfY1kg9T4fg1fI5ZcDfBfITxIX6c4QDoI9PwGoUC6Vg8F0jeIB6S/d9oK0oKab9gOReu+SbJBany/ia8RS64G+K8THqRvURwgLQE97yEUSDvLoUC6h3hA+genrSAtqLnHdiha922SDVLj+218jVhyNcB/i/AgfYfiAOkQ0PNeQoF0qREKpHuJB6R/dNoK0oKae22HonXfJdkgNb7fxdeIJVcD/HcID9L3KA6QloGe9xEKpJ31UCDdRzwg/ZPTVpAW1NxnOxSt+z7JBqnx/T6+Riy5GuC/R3iQfkBxgLQC9LyfUCANN2u/n3hA+menrSAtqLnfdiha90OSDVLj+0N8jVhyNcD/gPAg/YjiAGkV6PkAwUAabNb+APGA9C9OW0FaUPOA7VC07sckG6TG98f4GrHkaoD/EeFB+gmz76L5mfp8wlSj3oHO+a+4PJdNbi7EjPZ/bPvT4/8+o40QMq8uCLP81Yod9U8JXwd0jp8Rz7lijqpNNtC21o04t7VuNnVba93WWre1PjEP3dYamYdua30q/7qt9f/i6rbWyLi6rbWrn+f/7NvWupWMRWziba2T+se0rfVm989x/vv6HxHgH7yt+Wlt6y1hW3MO/vv6Lwnwj43b3dZZt/X283/2bevdim5bb46vYI5pW2uO+19f/xUB/sHbep/Wts4StvXGxu1u6xzTtsbYuN1tnWPa1pXj+ufrvyTAP8f4h6//YQH+sXGbSf1j2taX4/Ovr/9xAf45/v59/ZcE+Oe4/vn6nxLgn+P+39f/mAD/2Ljt5LmA2Rz/sxl5zAb0P+vE5bj/8fU/KcA/B/98/ZcE+Of4/OPrf1iAf47nP3z9Dwrwv9nPf47nP3z9Dwnwz/H8h6//sgD/HONfvv4rAvxzPP/h678qwL9e/5Fx47v+b/b6Y+O2WkZjLsf/XEYecwH9zzlxOa5/vv7LAvxz3P/5+p8U4J9j/tPX/4QA/xzXf1//VQH+Ofjv678kwD82bvdr/eZz/M9n5DEf0P+8+v8u7gA27ul+rWGf87Pe75tO2r30ov1awxFHq+gawoMAre5i79VgOwsfxGltWOz9N6eti70Lah60HYrW/ZxwJz+X78/xNWLdPWIU2KeHCAWUTrDvST1EPED5u9NWoBTUPGQ7FK17mGQDxfg+jK8RK1DGgH16hFBA2RFsO5ojxAOUL5y2AqWg5hHboWjdL0k2UIzvL/E1YsnVfJI6TPitU76iOEA6DvR8lFAgXa2FAulR4gHpP5y2grSg5lHboWjdr0k2SI3vr/E1YsnVAP8rwoP0G+G+TX2+yagR4nzqHWjoTwDzPEYo6O8IBv1jxAP9fzpthX5BzWO2Q9G635Js6Bvf3+JrdMqNAmvFDmif9h4wNQ/ajNgT19zum0+qBlxVx4P54zInu/ljM7MuvclRM6FjHlSoOP/fHP8F5MZYW+eWAQA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/strings/target/witness.tr b/crates/nargo_cli/tests/test_data/strings/target/witness.tr index d0f4c3b600f..0c0954aa1d0 100644 Binary files a/crates/nargo_cli/tests/test_data/strings/target/witness.tr and b/crates/nargo_cli/tests/test_data/strings/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/struct/target/main.json b/crates/nargo_cli/tests/test_data/struct/target/struct.json similarity index 100% rename from crates/nargo_cli/tests/test_data/struct/target/main.json rename to crates/nargo_cli/tests/test_data/struct/target/struct.json diff --git a/crates/nargo_cli/tests/test_data/struct_array_inputs/target/main.json b/crates/nargo_cli/tests/test_data/struct_array_inputs/target/struct_array_inputs.json similarity index 100% rename from crates/nargo_cli/tests/test_data/struct_array_inputs/target/main.json rename to crates/nargo_cli/tests/test_data/struct_array_inputs/target/struct_array_inputs.json diff --git a/crates/nargo_cli/tests/test_data/struct_fields_ordering/target/main.json b/crates/nargo_cli/tests/test_data/struct_fields_ordering/target/struct_fields_ordering.json similarity index 100% rename from crates/nargo_cli/tests/test_data/struct_fields_ordering/target/main.json rename to crates/nargo_cli/tests/test_data/struct_fields_ordering/target/struct_fields_ordering.json diff --git a/crates/nargo_cli/tests/test_data/struct_inputs/target/main.json b/crates/nargo_cli/tests/test_data/struct_inputs/target/main.json deleted file mode 100644 index 925e2f2a873..00000000000 --- a/crates/nargo_cli/tests/test_data/struct_inputs/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"struct","fields":[{"name":"foo","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"bar","type":{"kind":"field"}},{"name":"message","type":{"kind":"string","length":5}}]},"visibility":"public"},{"name":"z","type":{"kind":"struct","fields":[{"name":"val","type":{"kind":"field"}},{"name":"array","type":{"kind":"array","length":2,"type":{"kind":"field"}}},{"name":"message","type":{"kind":"string","length":5}}]},"visibility":"public"},{"name":"a","type":{"kind":"struct","fields":[{"name":"bar_struct","type":{"kind":"struct","fields":[{"name":"val","type":{"kind":"field"}},{"name":"array","type":{"kind":"array","length":2,"type":{"kind":"field"}}},{"name":"message","type":{"kind":"string","length":5}}]}},{"name":"baz","type":{"kind":"field"}}]},"visibility":"public"}],"param_witnesses":{"a":[17,18,19,20,21,22,23,24,25],"x":[1],"y":[2,3,4,5,6,7,8],"z":[9,10,11,12,13,14,15,16]},"return_type":{"kind":"field"},"return_witnesses":[19]},"bytecode":"H4sIAAAAAAAA/+2c3VPTQBTFLy0tIIjItwKCIAiCkDRpmwBCBeRDQEBA8FG0PPr/P9odbjI3mY4vezazncmdyewuQ07PPbv8ppMZ8pOI/tJTdbWuAl9zYt3dunrFupRal1PrntS6ly91X5FHYt0S398jfqfE96l61rr6hdZASvt5aj2YWr9IrYfE55SFlwHWGuR7hkSfkZfh1jUitEZT2mOp9XhqPZFaTwovfcLLKGuN8z2TlKwijw0ePafm+816pel67i+nEj4EVcevPtQCN3CrQfVPJfC8ZuAH9fAhrDuh63tN97Eaeo/OU/UJLUev3JdAX69xvpwi556urlSWjl65SM/S75SYd/NYaHMmygZ6otTnpHMcbPMz6Ieb2KQpA7rThDv8pvqexu+RIyStzzQqNESfAXseBvqaoc6DKNKz9PtGzHOIamrOcKBo3VmyG6Kq71n8HhmFKDrTqNAQ7Qf2PAL0NUedB1GkZ+n3rZjnENXUnONA0brzZDdEVd/z+D0yClF0plEVUj6R30R1tRao88CH9Cz9vhPzHHyamgscKFp3kewGn+p7Eb9HRsGHzjQqNPj6gVpLwPyyAh/QcwJ878U8B5+m5hIHitZdJrvBp/pexu+RUfChM42qAPbZB/S5AtTKCnwrZAZ8H8Q8B5+m5goHitZdJbvBp/pexe+RUfChM42qCPbZRVhYobTWcD1mBlGkZ+n3o5jnENXUXONA0brrZDdEVd/r+D36L0R1c1g35BP97bEb2PMGQKv5qCoMswLfBpkBn9y0HHyamhscKFrXJbvBp/p28XtkFHwVYP+Rtwr7dHn0KFloKJaAefgEg+LvrKDokxkoVsU8h6Kmps+BonVrZDcUVd81/B7FB9VjzzUe65QsNGzKwLwDgsGmmhVsAjIDm1DMc9hoagYcKFp3k+yGjep7E79H8UGts+dNHrcoWWjY9ADz3qbOg802mYHNJzHPYaOpuc2BonV3yG7YqL538HsUH9Qt9rzD4y4lCw2bXmDeDYLBppIVbBpkBjafxTyHjaZmgwNF6+6R3bBROnv4PYoP6i573uNxn5KF7mcfnHdUaCiOAn0eEAyKmT1wPyAzUPwi5jkUNTUPOFC07iHZDUXV9yF+j4w+cD8C9h95O2KfhzweU7LQUBwD5nFCMChm9sD9hMxA8auY51DU1DzhQNG6p2Q3FFXfp/g9ig/qMXs+5fGMkoWGzTgw73OCwSazZ2DnZAY238Q8h42m5jkHita9ILtho/q+wO9RfFDP2PMFj5eULDRsJoB5X1HnweaKzMDmu5jnsNHUvOJA0brXZDdsVN/X+D2KD+ole77m8YaShYbNJDDvW4LBJrMH7rdkBjY/xDyHjabmLQeK1r0ju2Gj+r7D71F8UG/Y8x2P95QsdD/3wLy7hMfohZfqD0wd+HYvClX/8xi9HLTdyzvViyijF3a2e6HmK5GH+p1/cJMvUAlVAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/struct_inputs/target/struct_inputs.json b/crates/nargo_cli/tests/test_data/struct_inputs/target/struct_inputs.json new file mode 100644 index 00000000000..1d72b648552 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/struct_inputs/target/struct_inputs.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"struct","fields":[{"name":"foo","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"bar","type":{"kind":"field"}},{"name":"message","type":{"kind":"string","length":5}}]},"visibility":"public"},{"name":"z","type":{"kind":"struct","fields":[{"name":"val","type":{"kind":"field"}},{"name":"array","type":{"kind":"array","length":2,"type":{"kind":"field"}}},{"name":"message","type":{"kind":"string","length":5}}]},"visibility":"public"},{"name":"a","type":{"kind":"struct","fields":[{"name":"bar_struct","type":{"kind":"struct","fields":[{"name":"val","type":{"kind":"field"}},{"name":"array","type":{"kind":"array","length":2,"type":{"kind":"field"}}},{"name":"message","type":{"kind":"string","length":5}}]}},{"name":"baz","type":{"kind":"field"}}]},"visibility":"public"}],"param_witnesses":{"a":[17,18,19,20,21,22,23,24,25],"x":[1],"y":[2,3,4,5,6,7,8],"z":[9,10,11,12,13,14,15,16]},"return_type":{"kind":"field"},"return_witnesses":[19]},"bytecode":"H4sIAAAAAAAA/+2c/U7UUBDFh/2SLxH5VkAQBEEQ2t2WbQUEBEFAQPAJRJf4/k/gTrhNhmbjP/dMc5vcmzSdC+zpmTPLL7ts6E8i+kuPq697VMyxKPa17tEv9vXcvpHbP8vt+81RN9fJzjVTN8Rj6uJxvAa7x5D42nBO+3luP5Lbv8jtR8V1KsLLsNEaMY8ZNd+rCi9j3WNcaE3ktCdz+6ncfjq3nxFeasLLhNGaMo+Zoaeras6H5twKdqKo0252wlb4K2im90kcRPH9ThImYZzEf5pJq9VJoqSd3qftIA2jVid8iNPWQ/C4BoRWYLfCl0Bfr3G+gqrJPb/6clkGditEepZ+Z0VdM+dKj+dEQ6Enyl0nn+NIj69BL64xpFkF3TnCPfm1+p7DzygQks5nmi00RAeBPY8Bfc1T+SCK9Cz9vhG1h6il5rwJFK27QG5DlPtewM9IFaLoTLOFhugQsOdxoK9FKh9EkZ6l37ei9hC11Fw0gaJ1l8htiHLfS/gZqUIUnWm2KjmfyFeitlrLVD7wIT1Lv+9E7cFnqblsAkXrrpDb4OO+V/AzUgUfOtNsocE3BNRaBeZXFPiAnp+A772oPfgsNVdNoGjdNXIbfNz3Gn5GquBDZ5qtCtjnANDnOlCrKPCtkw74Pojag89Sc90EitbdILfBx31v4GekCj50ptmqgn32ERZWKK1NXI+FQRTpWfr9KGoPUUvNTRMoWneL3IYo972Fn9F/IWqbw5aST/Srxxqw522AVueBV5oWBb5t0gGfHJoHn6XmtgkUrRuS2+DjvkP8jFSBUgdm2iQYUH4XBZQm6QClJWoPFEvNpgkUrRuR20DhviP8jFSB0gBmGhMMKHFRQIlJByg7ovZAsdSMTaBo3Ta5DRTuu42fkYpXHnxE+Ld6CZUDpM+APadUPpCmpAPST6L2ILXUTE2gaN1dchuk3PcufkYqXhn4CeFBukflAGk/sOd9goG0WRRI90kHpJ9F7UFqqblvAkXrHpDbIOW+D/AzUvHKwN8jPEgPHe9bPoeQfQtJOPQngD6PCAb9wj4oOSId6H8RtYe+peaRCRSte0xuQ5/7PsbPSBUok8BMTwgGlMI+KDkhHaB8FbUHiqXmiQkUrXtKbgOF+z7Fz0gVKFPATM8IBpTC/r53RjpA+SZqDxRLzTMTKFr3nNwGCvd9jp+Rild+JXVK+LelF1QOkE4De76k8oH0knRA+l3UHqSWmpcmULTuFbkNUu77Cj8jFa8M/AvCg/SaygHSGWDPNwQDaWEflNyQDkh/iNqD1FLzxgSK1r0lt0HKfd/iZ6TilYF/TXiQ3jneN8/nrseMbPvOfPI5u8EsA4R/oXvdmJf/xzi7GW+vm+XyjV+zG+T2uoHtK5EN/8w/Ewu/MHlYAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/struct_inputs/target/witness.tr b/crates/nargo_cli/tests/test_data/struct_inputs/target/witness.tr index 6ddf16de41f..ddb708ec03b 100644 Binary files a/crates/nargo_cli/tests/test_data/struct_inputs/target/witness.tr and b/crates/nargo_cli/tests/test_data/struct_inputs/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/submodules/target/main.json b/crates/nargo_cli/tests/test_data/submodules/target/submodules.json similarity index 100% rename from crates/nargo_cli/tests/test_data/submodules/target/main.json rename to crates/nargo_cli/tests/test_data/submodules/target/submodules.json diff --git a/crates/nargo_cli/tests/test_data/to_be_bytes/target/main.json b/crates/nargo_cli/tests/test_data/to_be_bytes/target/to_be_bytes.json similarity index 100% rename from crates/nargo_cli/tests/test_data/to_be_bytes/target/main.json rename to crates/nargo_cli/tests/test_data/to_be_bytes/target/to_be_bytes.json diff --git a/crates/nargo_cli/tests/test_data/to_bits/target/to_bits.json b/crates/nargo_cli/tests/test_data/to_bits/target/to_bits.json new file mode 100644 index 00000000000..4c3bb072cb3 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/to_bits/target/to_bits.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/2NkIAwAQGbG/yQAAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/to_bytes_integration/target/main.json b/crates/nargo_cli/tests/test_data/to_bytes_integration/target/to_bytes_integration.json similarity index 100% rename from crates/nargo_cli/tests/test_data/to_bytes_integration/target/main.json rename to crates/nargo_cli/tests/test_data/to_bytes_integration/target/to_bytes_integration.json diff --git a/crates/nargo_cli/tests/test_data/to_le_bytes/target/main.json b/crates/nargo_cli/tests/test_data/to_le_bytes/target/to_le_bytes.json similarity index 100% rename from crates/nargo_cli/tests/test_data/to_le_bytes/target/main.json rename to crates/nargo_cli/tests/test_data/to_le_bytes/target/to_le_bytes.json diff --git a/crates/nargo_cli/tests/test_data/tuples/target/main.json b/crates/nargo_cli/tests/test_data/tuples/target/main.json deleted file mode 100644 index a971c0ba0d0..00000000000 --- a/crates/nargo_cli/tests/test_data/tuples/target/main.json +++ /dev/null @@ -1 +0,0 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1ay27CMBDcJDzDs1AoRRRVtFJvVZwHJLf+SlHDZ/dbiiVHMmnUQz0bGRFfYjjM7sxONhsrb0T0Tr+Xq64f6hqYLeFoWFGwj+P8EOYiEp9BmB3TJIiT4z4VqUjS5CtMoyhP4/SQHbNDkIk4ysUpyaKTAvPAWE4FfwfM38NhBXq+rYq9q/3nqWuHgROV4pR1HFf8Bw3OUaQWA26bcIbl4t3G1yjQIK3WtK4m4BJPE+ho+6YJGGK6TEJ1ye4mIHl38TVibQJITV26NCo6V4dJU0COotj0zhh9YrxhJbAUWgb6VoFcFfS5FNNjLMA/zRIqs4ge0Hh9HEd2EyNyPalFTCb2zxgDqsHEvgpS/B7UYOI+0MQ+0MQDJmOU30NN80RyHgLr+hfnwGxB371HNXG2qc7jG6zzBMyZY5oaVuCa8t7gcmSZ0qWvRwy8n8C8i+WB8wRO0WIDzGt7JfpNgfoBPSO2QI51HecAtbw4zrnT9s1xjiHmVAmKxp2R3cc5kvcMXyPW4xzbNZV4PuEfvjuye+iQN/2EgfcL3d7QsQPm9Xol+s2B+gE9I5D61TV0ALW8GDrutX0zdBhizpWgaNwF2f2AlLwX+BqxDh1oTYtl8+nOEohVV+NbEk/je9D2TeMzxFwqQdG4K7K78UneK3yNWBsfUtNr/4LmUds3TcAQ01WConHXZP8XNGt8jVibAFJTV8tRv3mK9QOtuIwxbCwAAA==","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/tuples/target/tuples.json b/crates/nargo_cli/tests/test_data/tuples/target/tuples.json new file mode 100644 index 00000000000..fbef69192d8 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/tuples/target/tuples.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1a0U7jMBDcOFCgQOHg6HGIQ6h30r0hu0lo8savUNF+Nr8CsrSBbRpA4NnIFdkXu1Y73pm1J47V/0R0Q+thuL3j1oaFSwRWZm/zfDGbLlzm7u20mpeFzYv5belKV5TFw7TMskWZl7NqXs1s5fJs4ZZFlS0ZLAVjJS38EzD/FIdlZb5bLX0jxlJuBwqcqDFPU8dRyxh0co0ibSngbhNuwWrx3sbXyArIqDXtygQM6ZjAQPR7EwjENEpC7VDcJuB57+BrpGoCSE1Tet0omjknpKMtqG5OEftlDmlOu9zuibG6b+jVyAaiHnWdvNk90XqtEtE3/J30ne8kb+DInOrfj2jVcO+4tYGh4DlW1XwTFtcX8JEnMizadWPOVGHuGuuLG3/KG9/tEs5E9nAcOzMkRM5LjpZ0N86Qhtzui7HPGNKE1mvVNKQJfWxIbTi9Ib0dL4Y0FGL6z76Q14050YYkN1GoIQ0JZ0j7pLO5m/dDoXkiOR8A6/oeZxsW0Duxw444x1Tn0Tes8xGYs8bbzUELbijvS1yOKm/Pfl0fKvD+A+ZdRwrOE/hW6y6BeV1tiH7HQP2Aa8ZdATl2dc0K1HLlmvWH6PfXrIGYxywoGveE4r5m9bxP8DVSvWaNXVOPNyT8w3dCcR86/KY/UuD9l77foWMCzOvfhuh3CtQPuGYcUr+uDh1ALVcOHT9Fvz90BGKesqBo3DOK+wHpeZ/ha6R66EBrWkfMtztjIFZXxjcmHeP7Jfq98QVijllQNO45xW18nvc5vkaqxofUdNP/2fZb9HsTCMQ0LCga94LiNgHP+wJfI1UTQGpqRI5y89TxDN6YKq8EMAAA","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/type_aliases/Nargo.toml b/crates/nargo_cli/tests/test_data/type_aliases/Nargo.toml new file mode 100644 index 00000000000..a797cb0bbe2 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/type_aliases/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "type_aliases" +authors = [""] +compiler_version = "0.1" + +[dependencies] diff --git a/crates/nargo_cli/tests/test_data/type_aliases/Prover.toml b/crates/nargo_cli/tests/test_data/type_aliases/Prover.toml new file mode 100644 index 00000000000..771df41899d --- /dev/null +++ b/crates/nargo_cli/tests/test_data/type_aliases/Prover.toml @@ -0,0 +1 @@ +x = [2, 3] diff --git a/crates/nargo_cli/tests/test_data/type_aliases/src/main.nr b/crates/nargo_cli/tests/test_data/type_aliases/src/main.nr new file mode 100644 index 00000000000..6cfafc91b7d --- /dev/null +++ b/crates/nargo_cli/tests/test_data/type_aliases/src/main.nr @@ -0,0 +1,31 @@ +use dep::std; + +type Foo = [T; 2]; + +type Bar = Field; + +type Three = Two; +type Two = One; +type One = (A, B); + +struct MyStruct { + foo: Bar, +} + +fn main(x : [Field; 2]) { + let a: Foo = [1, 2]; + assert(a[0] != x[0]); + + let b: Bar = 2; + assert(x[0] == b); + + let c: u8 = 1; + let d: u32 = 2; + let e: Three = (c, d); + assert(e.0 == 1); + + let s = MyStruct { + foo: 10 + }; + assert(s.foo == 10); +} diff --git a/crates/nargo_cli/tests/test_data/type_aliases/target/type_aliases.json b/crates/nargo_cli/tests/test_data/type_aliases/target/type_aliases.json new file mode 100644 index 00000000000..b7bebf9cc9b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/type_aliases/target/type_aliases.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"array","length":2,"type":{"kind":"field"}},"visibility":"private"}],"param_witnesses":{"x":[1,2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/+1WSQ7DIAx0FmiqSn2LHSAxt36lUcn/n1BF4YBolAum6qFzsZVIg2eMRlwB4AY7VKxtrE3SQ/bvEavBydowj4EMPXH0Czu0bpmYmBy718jGBLY8+8XP6MmaQKvzZsUdjSBXl3BhGaiL+nM0mX4sAwnOjOm8/UGf7rKLVVfQBNk5uY/3g2+ih9dYUl+BV4Hc5a+lW8nvCBPKj5lLfVCV5myFvZUMPi3AFdYd3wo+DXWC75L0/+Ar5NTRUGneAX47+Dbdg/yOToMPyyDq6dkLcMMbg2cBBTYKAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/type_aliases/target/witness.tr b/crates/nargo_cli/tests/test_data/type_aliases/target/witness.tr new file mode 100644 index 00000000000..6c2ad03aa2e Binary files /dev/null and b/crates/nargo_cli/tests/test_data/type_aliases/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/unconstrained_empty/target/main.json b/crates/nargo_cli/tests/test_data/unconstrained_empty/target/unconstrained_empty.json similarity index 100% rename from crates/nargo_cli/tests/test_data/unconstrained_empty/target/main.json rename to crates/nargo_cli/tests/test_data/unconstrained_empty/target/unconstrained_empty.json diff --git a/crates/nargo_cli/tests/test_data/unit/target/unit.json b/crates/nargo_cli/tests/test_data/unit/target/unit.json new file mode 100644 index 00000000000..4c3bb072cb3 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/unit/target/unit.json @@ -0,0 +1 @@ +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[],"param_witnesses":{},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/2NkIAwAQGbG/yQAAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/vectors/target/main.json b/crates/nargo_cli/tests/test_data/vectors/target/vectors.json similarity index 100% rename from crates/nargo_cli/tests/test_data/vectors/target/main.json rename to crates/nargo_cli/tests/test_data/vectors/target/vectors.json diff --git a/crates/nargo_cli/tests/test_data/workspace/crates/a/Prover.toml b/crates/nargo_cli/tests/test_data/workspace/crates/a/Prover.toml new file mode 100644 index 00000000000..465ef562de4 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace/crates/a/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "1" diff --git a/crates/nargo_cli/tests/test_data/workspace/crates/a/src/main.nr b/crates/nargo_cli/tests/test_data/workspace/crates/a/src/main.nr index 81847a9031d..550e5034a7b 100644 --- a/crates/nargo_cli/tests/test_data/workspace/crates/a/src/main.nr +++ b/crates/nargo_cli/tests/test_data/workspace/crates/a/src/main.nr @@ -1,11 +1,3 @@ fn main(x : Field, y : pub Field) { - assert(x != y); -} - -#[test] -fn a() { - main(1, 2); - - // Uncomment to make test fail - // main(1, 1); + assert(x == y); } diff --git a/crates/nargo_cli/tests/test_data/workspace/crates/b/Prover.toml b/crates/nargo_cli/tests/test_data/workspace/crates/b/Prover.toml new file mode 100644 index 00000000000..a0397e89477 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace/crates/b/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "0" diff --git a/crates/nargo_cli/tests/test_data/workspace/crates/b/src/main.nr b/crates/nargo_cli/tests/test_data/workspace/crates/b/src/main.nr index 512f99feeca..6e170de75fc 100644 --- a/crates/nargo_cli/tests/test_data/workspace/crates/b/src/main.nr +++ b/crates/nargo_cli/tests/test_data/workspace/crates/b/src/main.nr @@ -1,11 +1,3 @@ fn main(x : Field, y : pub Field) { assert(x != y); } - -#[test] -fn b() { - main(1, 2); - - // Uncomment to make test fail - // main(1, 1); -} diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/a/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_default_member/a/Prover.toml new file mode 100644 index 00000000000..465ef562de4 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/a/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "1" diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/a/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_default_member/a/src/main.nr index 206dc46d57a..550e5034a7b 100644 --- a/crates/nargo_cli/tests/test_data/workspace_default_member/a/src/main.nr +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/a/src/main.nr @@ -1,11 +1,3 @@ fn main(x : Field, y : pub Field) { - assert(x != y); -} - -#[test] -fn test_main() { - main(1, 2); - - // Uncomment to make test fail - // main(1, 1); + assert(x == y); } diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/b/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_default_member/b/Nargo.toml new file mode 100644 index 00000000000..85c6119c62c --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/b/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "b" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/b/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_default_member/b/Prover.toml new file mode 100644 index 00000000000..83fcd8678e7 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/b/Prover.toml @@ -0,0 +1,3 @@ +# Deliberately setting these to fail to prove this is NOT executed since a default is specified +x = "1" +y = "1" diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/b/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_default_member/b/src/main.nr new file mode 100644 index 00000000000..6e170de75fc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/b/src/main.nr @@ -0,0 +1,3 @@ +fn main(x : Field, y : pub Field) { + assert(x != y); +} diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/target/main.json b/crates/nargo_cli/tests/test_data/workspace_default_member/target/a.json similarity index 52% rename from crates/nargo_cli/tests/test_data/workspace_default_member/target/main.json rename to crates/nargo_cli/tests/test_data/workspace_default_member/target/a.json index 5b013404f52..1c9071208c7 100644 --- a/crates/nargo_cli/tests/test_data/workspace_default_member/target/main.json +++ b/crates/nargo_cli/tests/test_data/workspace_default_member/target/a.json @@ -1 +1 @@ -{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/7WTMRLEIAhFMYkp9ywgGrHbq6yz5v5H2JkdCyaxC9LgWDw+H9gBwMM91p7fPeOzIKdYjEeMLYdGTB8MpUrCmOohJJQkfYMwN4mSSy0ZC0VudKbCZ4cthqzVrsc/yw28dMZeWmrWerfBexnsxD6hJ7jUufr4GvyZFp8xpG0C14Pd8s/q29vPCBXypvmpDx7sD8opnfqIfsM1RNtxBQAA","proving_key":null,"verification_key":null} \ No newline at end of file +{"backend":"acvm-backend-barretenberg","abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"public"}],"param_witnesses":{"x":[1],"y":[2]},"return_type":null,"return_witnesses":[]},"bytecode":"H4sIAAAAAAAA/82TQQ4DIQhFcWacZc8CoiPuepWaOvc/QpPGJmTqrpiUDcTFg//BHQA8fMfa871n/C3IKRbjEWPLoRHTA0OpkjCmeggJJUnPIMxNouRSS8ZCkRudqfDZYYsha7XT+Ga5gZfO2EvLmfW826BeBjexT9AElz5XH2+DN9PmM5a0TeB6sDv+Wbq9/Y5QIf/aU6dm/NT6E70AIbviMnEFAAA=","proving_key":null,"verification_key":null} \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/workspace_default_member/target/witness.tr b/crates/nargo_cli/tests/test_data/workspace_default_member/target/witness.tr index a51064da4b6..f1ea0249fe9 100644 Binary files a/crates/nargo_cli/tests/test_data/workspace_default_member/target/witness.tr and b/crates/nargo_cli/tests/test_data/workspace_default_member/target/witness.tr differ diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_fail/Nargo.toml new file mode 100644 index 00000000000..36db098686f --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/Nargo.toml @@ -0,0 +1,2 @@ +[workspace] +members = ["crates/a", "crates/b"] diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Nargo.toml new file mode 100644 index 00000000000..5ff1a743e3d --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "a" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Prover.toml new file mode 100644 index 00000000000..b76c88bf536 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/Prover.toml @@ -0,0 +1,3 @@ +# Deliberately setting these to fail to prove this is being executed +x = "1" +y = "2" diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/src/main.nr new file mode 100644 index 00000000000..550e5034a7b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/a/src/main.nr @@ -0,0 +1,3 @@ +fn main(x : Field, y : pub Field) { + assert(x == y); +} diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Nargo.toml new file mode 100644 index 00000000000..8ae69a781eb --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "b" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Prover.toml new file mode 100644 index 00000000000..a0397e89477 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "0" diff --git a/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/src/main.nr new file mode 100644 index 00000000000..6e170de75fc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_fail/crates/b/src/main.nr @@ -0,0 +1,3 @@ +fn main(x : Field, y : pub Field) { + assert(x != y); +} diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_missing_toml/Nargo.toml new file mode 100644 index 00000000000..36db098686f --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/Nargo.toml @@ -0,0 +1,2 @@ +[workspace] +members = ["crates/a", "crates/b"] diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/Prover.toml new file mode 100644 index 00000000000..465ef562de4 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "1" diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/src/main.nr new file mode 100644 index 00000000000..550e5034a7b --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/a/src/main.nr @@ -0,0 +1,3 @@ +fn main(x : Field, y : pub Field) { + assert(x == y); +} diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Nargo.toml b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Nargo.toml new file mode 100644 index 00000000000..8ae69a781eb --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "b" +authors = [""] +compiler_version = "0.8.0" + +[dependencies] \ No newline at end of file diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Prover.toml b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Prover.toml new file mode 100644 index 00000000000..a0397e89477 --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/Prover.toml @@ -0,0 +1,2 @@ +x = "1" +y = "0" diff --git a/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/src/main.nr b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/src/main.nr new file mode 100644 index 00000000000..6e170de75fc --- /dev/null +++ b/crates/nargo_cli/tests/test_data/workspace_missing_toml/crates/b/src/main.nr @@ -0,0 +1,3 @@ +fn main(x : Field, y : pub Field) { + assert(x != y); +} diff --git a/crates/nargo_cli/tests/test_data/xor/target/main.json b/crates/nargo_cli/tests/test_data/xor/target/xor.json similarity index 100% rename from crates/nargo_cli/tests/test_data/xor/target/main.json rename to crates/nargo_cli/tests/test_data/xor/target/xor.json diff --git a/crates/noirc_abi/src/input_parser/json.rs b/crates/noirc_abi/src/input_parser/json.rs index 7a0cd76698d..6468b48c857 100644 --- a/crates/noirc_abi/src/input_parser/json.rs +++ b/crates/noirc_abi/src/input_parser/json.rs @@ -59,7 +59,7 @@ pub(crate) fn serialize_to_json( #[derive(Debug, Deserialize, Serialize, Clone)] #[serde(untagged)] -pub enum JsonTypes { +pub(super) enum JsonTypes { // This is most likely going to be a hex string // But it is possible to support UTF-8 String(String), @@ -78,7 +78,7 @@ pub enum JsonTypes { } impl JsonTypes { - pub fn try_from_input_value( + pub(super) fn try_from_input_value( value: &InputValue, abi_type: &AbiType, ) -> Result { diff --git a/crates/noirc_abi/src/input_parser/mod.rs b/crates/noirc_abi/src/input_parser/mod.rs index 6818f40786c..e4adbb3d8cf 100644 --- a/crates/noirc_abi/src/input_parser/mod.rs +++ b/crates/noirc_abi/src/input_parser/mod.rs @@ -1,4 +1,4 @@ -pub mod json; +mod json; mod toml; use std::collections::BTreeMap; @@ -6,8 +6,8 @@ use std::collections::BTreeMap; use acvm::FieldElement; use serde::Serialize; -use crate::errors::InputParserError; -use crate::{Abi, AbiType}; +use crate::errors::{AbiError, InputParserError}; +use crate::{decode_value, Abi, AbiType}; /// This is what all formats eventually transform into /// For example, a toml file will parse into TomlTypes /// and those TomlTypes will be mapped to Value @@ -67,6 +67,35 @@ impl InputValue { } } +/// In order to display an `InputValue` we need an `AbiType` to accurately +/// convert the value into a human-readable format. +pub struct InputValueDisplay { + input_value: InputValue, + abi_type: AbiType, +} + +impl InputValueDisplay { + pub fn try_from_fields( + field_iterator: &mut impl Iterator, + abi_type: AbiType, + ) -> Result { + let input_value = decode_value(field_iterator, &abi_type)?; + Ok(InputValueDisplay { input_value, abi_type }) + } +} + +impl std::fmt::Display for InputValueDisplay { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // From the docs: https://doc.rust-lang.org/std/fmt/struct.Error.html + // This type does not support transmission of an error other than that an error + // occurred. Any extra information must be arranged to be transmitted through + // some other means. + let json_value = json::JsonTypes::try_from_input_value(&self.input_value, &self.abi_type) + .map_err(|_| std::fmt::Error)?; + write!(f, "{}", serde_json::to_string(&json_value).map_err(|_| std::fmt::Error)?) + } +} + /// The different formats that are supported when parsing /// the initial witness values #[cfg_attr(test, derive(strum_macros::EnumIter))] diff --git a/crates/noirc_abi/src/lib.rs b/crates/noirc_abi/src/lib.rs index 86f9edc73bd..5f8c22a6652 100644 --- a/crates/noirc_abi/src/lib.rs +++ b/crates/noirc_abi/src/lib.rs @@ -368,7 +368,7 @@ impl Abi { } } -pub fn decode_value( +fn decode_value( field_iterator: &mut impl Iterator, value_type: &AbiType, ) -> Result { diff --git a/crates/noirc_driver/src/lib.rs b/crates/noirc_driver/src/lib.rs index f2537bb88fe..c624dda2fce 100644 --- a/crates/noirc_driver/src/lib.rs +++ b/crates/noirc_driver/src/lib.rs @@ -25,10 +25,10 @@ pub use program::CompiledProgram; #[derive(Args, Clone, Debug, Default, Serialize, Deserialize)] pub struct CompileOptions { /// Emit debug information for the intermediate SSA IR - #[arg(short, long)] + #[arg(long, hide = true)] pub show_ssa: bool, - #[arg(long)] + #[arg(long, hide = true)] pub show_brillig: bool, /// Display the ACIR for compiled circuit @@ -36,7 +36,7 @@ pub struct CompileOptions { pub print_acir: bool, /// Treat all warnings as errors - #[arg(short, long)] + #[arg(long)] pub deny_warnings: bool, } @@ -52,45 +52,24 @@ pub fn compile_file( context: &mut Context, root_file: &Path, ) -> Result<(CompiledProgram, Warnings), ErrorsAndWarnings> { - let crate_id = create_local_crate(context, root_file, CrateType::Binary); + let crate_id = prepare_crate(context, root_file, CrateType::Binary); compile_main(context, crate_id, &CompileOptions::default()) } -/// Adds the File with the local crate root to the file system -/// and adds the local crate to the graph -/// XXX: This may pose a problem with workspaces, where you can change the local crate and where -/// we have multiple binaries in one workspace -/// A Fix would be for the driver instance to store the local crate id. -// Granted that this is the only place which relies on the local crate being first -pub fn create_local_crate( - context: &mut Context, - file_name: &Path, - crate_type: CrateType, -) -> CrateId { +/// Adds the file from the file system at `Path` to the crate graph +pub fn prepare_crate(context: &mut Context, file_name: &Path, crate_type: CrateType) -> CrateId { let root_file_id = context.file_manager.add_file(file_name).unwrap(); context.crate_graph.add_crate_root(crate_type, root_file_id) } -/// Creates a Non Local Crate. A Non Local Crate is any crate which is the not the crate that -/// the compiler is compiling. -pub fn create_non_local_crate( - context: &mut Context, - file_name: &Path, - crate_type: CrateType, -) -> CrateId { - let root_file_id = context.file_manager.add_file(file_name).unwrap(); - - // You can add any crate type to the crate graph - // but you cannot depend on Binaries - context.crate_graph.add_crate_root(crate_type, root_file_id) -} - /// Adds a edge in the crate graph for two crates -pub fn add_dep(context: &mut Context, this_crate: CrateId, depends_on: CrateId, crate_name: &str) { - let crate_name = - crate_name.parse().expect("crate name contains blacklisted characters, please remove"); - +pub fn add_dep( + context: &mut Context, + this_crate: CrateId, + depends_on: CrateId, + crate_name: CrateName, +) { // Cannot depend on a binary if context.crate_graph.crate_type(depends_on) == CrateType::Binary { panic!("crates cannot depend on binaries. {crate_name:?} is a binary crate") @@ -142,15 +121,7 @@ pub fn check_crate( propagate_dep(context, std_crate, &std_crate_name.parse().unwrap()); let mut errors = vec![]; - match context.crate_graph.crate_type(crate_id) { - CrateType::Workspace => { - let keys: Vec<_> = context.crate_graph.iter_keys().collect(); // avoid borrow checker - for crate_id in keys { - CrateDefMap::collect_defs(crate_id, context, &mut errors); - } - } - _ => CrateDefMap::collect_defs(crate_id, context, &mut errors), - } + CrateDefMap::collect_defs(crate_id, context, &mut errors); if has_errors(&errors, deny_warnings) { Err(errors) @@ -192,7 +163,7 @@ pub fn compile_main( } }; - let compiled_program = compile_no_check(context, true, options, main)?; + let compiled_program = compile_no_check(context, options, main)?; if options.print_acir { println!("Compiled ACIR for main (unoptimized):"); @@ -259,7 +230,7 @@ fn compile_contract( let mut errs = Vec::new(); for function_id in &contract.functions { let name = context.function_name(function_id).to_owned(); - let function = match compile_no_check(context, true, options, *function_id) { + let function = match compile_no_check(context, options, *function_id) { Ok(function) => function, Err(err) => { errs.push(err); @@ -296,14 +267,12 @@ fn compile_contract( #[allow(deprecated)] pub fn compile_no_check( context: &Context, - show_output: bool, options: &CompileOptions, main_function: FuncId, ) -> Result { let program = monomorphize(main_function, &context.def_interner); - let (circuit, debug, abi) = - create_circuit(program, options.show_ssa, options.show_brillig, show_output)?; + let (circuit, debug, abi) = create_circuit(program, options.show_ssa, options.show_brillig)?; Ok(CompiledProgram { circuit, debug, abi }) } diff --git a/crates/noirc_evaluator/src/brillig/brillig_gen.rs b/crates/noirc_evaluator/src/brillig/brillig_gen.rs index 3ba04ed1afb..a1e82bbf443 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_gen.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_gen.rs @@ -4,7 +4,7 @@ pub(crate) mod brillig_directive; pub(crate) mod brillig_fn; pub(crate) mod brillig_slice_ops; -use crate::ssa_refactor::ir::{function::Function, post_order::PostOrder}; +use crate::ssa::ir::{function::Function, post_order::PostOrder}; use std::collections::HashMap; diff --git a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index 4de052aad9d..5e66519e4ad 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -4,12 +4,13 @@ use crate::brillig::brillig_gen::brillig_slice_ops::{ use crate::brillig::brillig_ir::{ BrilligBinaryOp, BrilligContext, BRILLIG_INTEGER_ARITHMETIC_BIT_SIZE, }; -use crate::ssa_refactor::ir::function::FunctionId; -use crate::ssa_refactor::ir::instruction::{Endian, Intrinsic}; -use crate::ssa_refactor::ir::{ +use crate::ssa::ir::{ basic_block::{BasicBlock, BasicBlockId}, dfg::DataFlowGraph, - instruction::{Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction}, + function::FunctionId, + instruction::{ + Binary, BinaryOp, Endian, Instruction, InstructionId, Intrinsic, TerminatorInstruction, + }, types::{NumericType, Type}, value::{Value, ValueId}, }; @@ -336,10 +337,10 @@ impl<'block> BrilligBlock<'block> { dfg.instruction_results(instruction_id)[0], dfg, ); - + let heap_vec = self.brillig_context.extract_heap_vector(target_slice); self.brillig_context.radix_instruction( source, - self.function_context.extract_heap_vector(target_slice), + heap_vec, radix, limb_count, matches!(endianness, Endian::Big), @@ -355,10 +356,10 @@ impl<'block> BrilligBlock<'block> { ); let radix = self.brillig_context.make_constant(2_usize.into()); - + let heap_vec = self.brillig_context.extract_heap_vector(target_slice); self.brillig_context.radix_instruction( source, - self.function_context.extract_heap_vector(target_slice), + heap_vec, radix, limb_count, matches!(endianness, Endian::Big), @@ -589,7 +590,7 @@ impl<'block> BrilligBlock<'block> { dfg.instruction_results(instruction_id)[0], dfg, ); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); let item_value = self.convert_ssa_register_value(arguments[1], dfg); slice_push_back_operation( self.brillig_context, @@ -604,7 +605,7 @@ impl<'block> BrilligBlock<'block> { dfg.instruction_results(instruction_id)[0], dfg, ); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); let item_value = self.convert_ssa_register_value(arguments[1], dfg); slice_push_front_operation( self.brillig_context, @@ -618,7 +619,7 @@ impl<'block> BrilligBlock<'block> { let target_variable = self.function_context.create_variable(self.brillig_context, results[0], dfg); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); let pop_item = self.function_context.create_register_variable( self.brillig_context, @@ -643,7 +644,7 @@ impl<'block> BrilligBlock<'block> { ); let target_variable = self.function_context.create_variable(self.brillig_context, results[1], dfg); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); slice_pop_front_operation( self.brillig_context, @@ -659,7 +660,7 @@ impl<'block> BrilligBlock<'block> { let target_variable = self.function_context.create_variable(self.brillig_context, results[0], dfg); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); slice_insert_operation( self.brillig_context, target_vector, @@ -674,7 +675,7 @@ impl<'block> BrilligBlock<'block> { let target_variable = self.function_context.create_variable(self.brillig_context, results[0], dfg); - let target_vector = self.function_context.extract_heap_vector(target_variable); + let target_vector = self.brillig_context.extract_heap_vector(target_variable); let removed_item_register = self.function_context.create_register_variable( self.brillig_context, @@ -775,7 +776,7 @@ impl<'block> BrilligBlock<'block> { fn convert_ssa_value(&mut self, value_id: ValueId, dfg: &DataFlowGraph) -> RegisterOrMemory { let value = &dfg[value_id]; - let variable = match value { + match value { Value::Param { .. } | Value::Instruction { .. } => { // All block parameters and instruction results should have already been // converted to registers so we fetch from the cache. @@ -800,10 +801,29 @@ impl<'block> BrilligBlock<'block> { value_id, dfg, ); - let heap_array = self.function_context.extract_heap_array(new_variable); - self.brillig_context - .allocate_fixed_length_array(heap_array.pointer, heap_array.size); + // Initialize the variable + let pointer = match new_variable { + RegisterOrMemory::HeapArray(heap_array) => { + self.brillig_context + .allocate_fixed_length_array(heap_array.pointer, array.len()); + + heap_array.pointer + } + RegisterOrMemory::HeapVector(heap_vector) => { + self.brillig_context + .const_instruction(heap_vector.size, array.len().into()); + self.brillig_context + .allocate_array_instruction(heap_vector.pointer, heap_vector.size); + + heap_vector.pointer + } + _ => unreachable!( + "ICE: Cannot initialize array value created as {new_variable:?}" + ), + }; + + // Write the items // Allocate a register for the iterator let iterator_register = self.brillig_context.make_constant(0_usize.into()); @@ -811,11 +831,7 @@ impl<'block> BrilligBlock<'block> { for element_id in array.iter() { let element_variable = self.convert_ssa_value(*element_id, dfg); // Store the item in memory - self.store_variable_in_array( - heap_array.pointer, - iterator_register, - element_variable, - ); + self.store_variable_in_array(pointer, iterator_register, element_variable); // Increment the iterator self.brillig_context.usize_op_in_place(iterator_register, BinaryIntOp::Add, 1); } @@ -827,8 +843,7 @@ impl<'block> BrilligBlock<'block> { _ => { todo!("ICE: Cannot convert value {value:?}") } - }; - variable + } } /// Converts an SSA `ValueId` into a `RegisterIndex`. Initializes if necessary. @@ -862,7 +877,7 @@ impl<'block> BrilligBlock<'block> { Type::Slice(_) => { let variable = self.function_context.create_variable(self.brillig_context, result, dfg); - let vector = self.function_context.extract_heap_vector(variable); + let vector = self.brillig_context.extract_heap_vector(variable); // Set the pointer to the current stack frame // The stack pointer will then be update by the caller of this method @@ -966,8 +981,6 @@ pub(crate) fn convert_ssa_binary_op_to_brillig_binary_op( BinaryOp::And => BinaryIntOp::And, BinaryOp::Or => BinaryIntOp::Or, BinaryOp::Xor => BinaryIntOp::Xor, - BinaryOp::Shl => BinaryIntOp::Shl, - BinaryOp::Shr => BinaryIntOp::Shr, }; BrilligBinaryOp::Integer { op: operation, bit_size } diff --git a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs index 219a954a595..93e760f9737 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs @@ -1,4 +1,6 @@ -use acvm::acir::brillig::{BinaryFieldOp, Opcode as BrilligOpcode, RegisterIndex, Value}; +use acvm::acir::brillig::{ + BinaryFieldOp, BinaryIntOp, Opcode as BrilligOpcode, RegisterIndex, Value, +}; /// Generates brillig bytecode which computes the inverse of its input if not null, and zero else. pub(crate) fn directive_invert() -> Vec { @@ -29,3 +31,59 @@ pub(crate) fn directive_invert() -> Vec { BrilligOpcode::Stop, ] } + +/// Generates brillig bytecode which computes `a / b` and returns the quotient and remainder. +/// It returns `(0,0)` if the predicate is null. +/// +/// +/// This is equivalent to the Noir (psuedo)code +/// +/// ```ignore +/// fn quotient(a: T, b: T, predicate: bool) -> (T,T) { +/// if predicate != 0 { +/// (a/b, a-a/b*b) +/// } else { +/// (0,0) +/// } +/// } +/// ``` +pub(crate) fn directive_quotient(bit_size: u32) -> Vec { + // `a` is (0) (i.e register index 0) + // `b` is (1) + // `predicate` is (2) + vec![ + // If the predicate is zero, we jump to the exit segment + BrilligOpcode::JumpIfNot { condition: RegisterIndex::from(2), location: 6 }, + //q = a/b is set into register (3) + BrilligOpcode::BinaryIntOp { + op: BinaryIntOp::UnsignedDiv, + lhs: RegisterIndex::from(0), + rhs: RegisterIndex::from(1), + destination: RegisterIndex::from(3), + bit_size, + }, + //(1)= q*b + BrilligOpcode::BinaryIntOp { + op: BinaryIntOp::Mul, + lhs: RegisterIndex::from(3), + rhs: RegisterIndex::from(1), + destination: RegisterIndex::from(1), + bit_size, + }, + //(1) = a-q*b + BrilligOpcode::BinaryIntOp { + op: BinaryIntOp::Sub, + lhs: RegisterIndex::from(0), + rhs: RegisterIndex::from(1), + destination: RegisterIndex::from(1), + bit_size, + }, + //(0) = q + BrilligOpcode::Mov { destination: RegisterIndex::from(0), source: RegisterIndex::from(3) }, + BrilligOpcode::Stop, + // Exit segment: we return 0,0 + BrilligOpcode::Const { destination: RegisterIndex::from(0), value: Value::from(0_usize) }, + BrilligOpcode::Const { destination: RegisterIndex::from(1), value: Value::from(0_usize) }, + BrilligOpcode::Stop, + ] +} diff --git a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs index 1a751d28b23..7c4cb5e2ced 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs @@ -8,7 +8,7 @@ use crate::{ artifact::{BrilligParameter, Label}, BrilligContext, }, - ssa_refactor::ir::{ + ssa::ir::{ dfg::DataFlowGraph, function::{Function, FunctionId}, types::{CompositeType, Type}, @@ -115,13 +115,6 @@ impl FunctionContext { } } - pub(crate) fn extract_heap_vector(&self, variable: RegisterOrMemory) -> HeapVector { - match variable { - RegisterOrMemory::HeapVector(vector) => vector, - _ => unreachable!("ICE: Expected vector, got {variable:?}"), - } - } - /// Collects the registers that a given variable is stored in. pub(crate) fn extract_registers(&self, variable: RegisterOrMemory) -> Vec { match variable { diff --git a/crates/noirc_evaluator/src/brillig/brillig_ir.rs b/crates/noirc_evaluator/src/brillig/brillig_ir.rs index ac0103dd9ed..4471d507579 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_ir.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_ir.rs @@ -951,6 +951,18 @@ impl BrilligContext { self.deallocate_register(end_value_register); self.deallocate_register(index_at_end_of_array); } + + pub(crate) fn extract_heap_vector(&mut self, variable: RegisterOrMemory) -> HeapVector { + match variable { + RegisterOrMemory::HeapVector(vector) => vector, + RegisterOrMemory::HeapArray(array) => { + let size = self.allocate_register(); + self.const_instruction(size, array.size.into()); + HeapVector { pointer: array.pointer, size } + } + _ => unreachable!("ICE: Expected vector, got {variable:?}"), + } + } } /// Type to encapsulate the binary operation types in Brillig diff --git a/crates/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/crates/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs index 75716e49177..2bb753de760 100644 --- a/crates/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs +++ b/crates/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs @@ -73,8 +73,9 @@ impl DebugToString for BinaryIntOp { BinaryIntOp::And => "&&".into(), BinaryIntOp::Or => "||".into(), BinaryIntOp::Xor => "^".into(), - BinaryIntOp::Shl => "<<".into(), - BinaryIntOp::Shr => ">>".into(), + BinaryIntOp::Shl | BinaryIntOp::Shr => { + unreachable!("bit shift should have been replaced") + } } } } diff --git a/crates/noirc_evaluator/src/brillig/mod.rs b/crates/noirc_evaluator/src/brillig/mod.rs index 105475323a7..0c6ddd53a4e 100644 --- a/crates/noirc_evaluator/src/brillig/mod.rs +++ b/crates/noirc_evaluator/src/brillig/mod.rs @@ -5,7 +5,7 @@ use self::{ brillig_gen::{brillig_fn::FunctionContext, convert_ssa_function}, brillig_ir::artifact::{BrilligArtifact, Label}, }; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ function::{Function, FunctionId, RuntimeType}, value::Value, diff --git a/crates/noirc_evaluator/src/errors.rs b/crates/noirc_evaluator/src/errors.rs index 2d8b02008c6..27a87ccce36 100644 --- a/crates/noirc_evaluator/src/errors.rs +++ b/crates/noirc_evaluator/src/errors.rs @@ -1,151 +1,101 @@ +//! Noir Evaluator has two types of errors +//! +//! [RuntimeError]s that should be displayed to the user +//! +//! [InternalError]s that are used for checking internal logics of the SSA +//! +//! An Error of the former is a user Error +//! +//! An Error of the latter is an error in the implementation of the compiler +use acvm::FieldElement; use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic, Location}; use thiserror::Error; -#[derive(Debug)] -pub struct RuntimeError { - pub location: Option, - pub kind: RuntimeErrorKind, -} - -impl RuntimeError { - // XXX: In some places, we strip the span because we do not want span to - // be introduced into the binary op or low level function code, for simplicity. - // - // It's possible to have it there, but it means we will need to proliferate the code with span - // - // This does make error reporting, less specific! - pub fn remove_span(self) -> RuntimeErrorKind { - self.kind - } - - pub fn new(kind: RuntimeErrorKind, location: Option) -> RuntimeError { - RuntimeError { location, kind } - } - - // Keep one of the two location which is Some, if possible - // This is used when we optimize instructions so that we do not lose track of location - pub fn merge_location(a: Option, b: Option) -> Option { - match (a, b) { - (Some(loc), _) | (_, Some(loc)) => Some(loc), - (None, None) => None, - } - } +#[derive(Debug, PartialEq, Eq, Clone, Error)] +pub enum RuntimeError { + // We avoid showing the actual lhs and rhs since most of the time they are just 0 + // and 1 respectively. This would confuse users if a constraint such as + // assert(foo < bar) fails with "failed constraint: 0 = 1." + #[error("Failed constraint")] + FailedConstraint { lhs: FieldElement, rhs: FieldElement, location: Option }, + #[error(transparent)] + InternalError(#[from] InternalError), + #[error("Index out of bounds, array has size {index:?}, but index was {array_size:?}")] + IndexOutOfBounds { index: usize, array_size: usize, location: Option }, + #[error("All Witnesses are by default u{num_bits:?} Applying this type does not apply any constraints.\n We also currently do not allow integers of size more than {num_bits:?}, this will be handled by BigIntegers.")] + InvalidRangeConstraint { num_bits: u32, location: Option }, + #[error("Expected array index to fit into a u64")] + TypeConversion { from: String, into: String, location: Option }, + #[error("{name:?} is not initialized")] + UnInitialized { name: String, location: Option }, + #[error("Integer sized {num_bits:?} is over the max supported size of {max_num_bits:?}")] + UnsupportedIntegerSize { num_bits: u32, max_num_bits: u32, location: Option }, } -impl From for RuntimeError { - fn from(kind: RuntimeErrorKind) -> RuntimeError { - RuntimeError { location: None, kind } - } +#[derive(Debug, PartialEq, Eq, Clone, Error)] +pub enum InternalError { + #[error("ICE: Both expressions should have degree<=1")] + DegreeNotReduced { location: Option }, + #[error("Try to get element from empty array")] + EmptyArray { location: Option }, + #[error("ICE: {message:?}")] + General { message: String, location: Option }, + #[error("ICE: {name:?} missing {arg:?} arg")] + MissingArg { name: String, arg: String, location: Option }, + #[error("ICE: {name:?} should be a constant")] + NotAConstant { name: String, location: Option }, + #[error("ICE: Undeclared AcirVar")] + UndeclaredAcirVar { location: Option }, + #[error("ICE: Expected {expected:?}, found {found:?}")] + UnExpected { expected: String, found: String, location: Option }, } impl From for FileDiagnostic { - fn from(err: RuntimeError) -> Self { - let file_id = err.location.map(|loc| loc.file).unwrap(); - FileDiagnostic { file_id, diagnostic: err.into() } + fn from(error: RuntimeError) -> Self { + match error { + RuntimeError::InternalError(ref ice_error) => match ice_error { + InternalError::DegreeNotReduced { location } + | InternalError::EmptyArray { location } + | InternalError::General { location, .. } + | InternalError::MissingArg { location, .. } + | InternalError::NotAConstant { location, .. } + | InternalError::UndeclaredAcirVar { location } + | InternalError::UnExpected { location, .. } => { + let file_id = location.map(|loc| loc.file).unwrap(); + FileDiagnostic { file_id, diagnostic: error.into() } + } + }, + RuntimeError::FailedConstraint { location, .. } + | RuntimeError::IndexOutOfBounds { location, .. } + | RuntimeError::InvalidRangeConstraint { location, .. } + | RuntimeError::TypeConversion { location, .. } + | RuntimeError::UnInitialized { location, .. } + | RuntimeError::UnsupportedIntegerSize { location, .. } => { + let file_id = location.map(|loc| loc.file).unwrap(); + FileDiagnostic { file_id, diagnostic: error.into() } + } + } } } -#[derive(Error, Debug)] -pub enum RuntimeErrorKind { - // Array errors - #[error("Out of bounds")] - ArrayOutOfBounds { index: u128, bound: u128 }, - - #[error("index out of bounds: the len is {index} but the index is {bound}")] - IndexOutOfBounds { index: u32, bound: u128 }, - - #[error("cannot call {func_name} function in non main function")] - FunctionNonMainContext { func_name: String }, - - // Environment errors - #[error("Cannot find Array")] - ArrayNotFound { found_type: String, name: String }, - - #[error("Not an object")] - NotAnObject, - - #[error("Invalid id")] - InvalidId, - - #[error("Attempt to divide by zero")] - DivisionByZero, - - #[error("Failed range constraint when constraining to {0} bits")] - FailedRangeConstraint(u32), - - #[error("Unsupported integer size of {num_bits} bits. The maximum supported size is {max_num_bits} bits.")] - UnsupportedIntegerSize { num_bits: u32, max_num_bits: u32 }, - - #[error("Failed constraint")] - FailedConstraint, - - #[error( - "All Witnesses are by default u{0}. Applying this type does not apply any constraints." - )] - DefaultWitnesses(u32), - - #[error("Constraint is always false")] - ConstraintIsAlwaysFalse, - - #[error("ICE: cannot convert signed {0} bit size into field")] - CannotConvertSignedIntoField(u32), - - #[error("we do not allow private ABI inputs to be returned as public outputs")] - PrivateAbiInput, - - #[error("unimplemented")] - Unimplemented(String), - - #[error("Unsupported operation error")] - UnsupportedOp { op: String, first_type: String, second_type: String }, -} - impl From for Diagnostic { fn from(error: RuntimeError) -> Diagnostic { - let span = - if let Some(loc) = error.location { loc.span } else { noirc_errors::Span::new(0..0) }; - match &error.kind { - RuntimeErrorKind::ArrayOutOfBounds { index, bound } => Diagnostic::simple_error( - "index out of bounds".to_string(), - format!("out of bounds error, index is {index} but length is {bound}"), - span, - ), - RuntimeErrorKind::ArrayNotFound { found_type, name } => Diagnostic::simple_error( - format!("cannot find an array with name {name}"), - format!("{found_type} has type"), - span, + match error { + RuntimeError::InternalError(_) => Diagnostic::simple_error( + "Internal Consistency Evaluators Errors: \n + This is likely a bug. Consider Opening an issue at https://github.com/noir-lang/noir/issues".to_owned(), + "".to_string(), + noirc_errors::Span::new(0..0) ), - RuntimeErrorKind::NotAnObject - | RuntimeErrorKind::InvalidId - | RuntimeErrorKind::DivisionByZero - | RuntimeErrorKind::FailedRangeConstraint(_) - | RuntimeErrorKind::UnsupportedIntegerSize { .. } - | RuntimeErrorKind::FailedConstraint - | RuntimeErrorKind::DefaultWitnesses(_) - | RuntimeErrorKind::CannotConvertSignedIntoField(_) - | RuntimeErrorKind::IndexOutOfBounds { .. } - | RuntimeErrorKind::PrivateAbiInput => { - Diagnostic::simple_error("".to_owned(), error.kind.to_string(), span) + RuntimeError::FailedConstraint { location, .. } + | RuntimeError::IndexOutOfBounds { location, .. } + | RuntimeError::InvalidRangeConstraint { location, .. } + | RuntimeError::TypeConversion { location, .. } + | RuntimeError::UnInitialized { location, .. } + | RuntimeError::UnsupportedIntegerSize { location, .. } => { + let span = if let Some(loc) = location { loc.span } else { noirc_errors::Span::new(0..0) }; + Diagnostic::simple_error("".to_owned(), error.to_string(), span) } - RuntimeErrorKind::UnsupportedOp { op, first_type, second_type } => { - Diagnostic::simple_error( - "unsupported operation".to_owned(), - format!("no support for {op} with types {first_type} and {second_type}"), - span, - ) - } - RuntimeErrorKind::ConstraintIsAlwaysFalse if error.location.is_some() => { - Diagnostic::simple_error("".to_owned(), error.kind.to_string(), span) - } - RuntimeErrorKind::ConstraintIsAlwaysFalse => { - Diagnostic::from_message(&error.kind.to_string()) - } - RuntimeErrorKind::Unimplemented(message) => Diagnostic::from_message(message), - RuntimeErrorKind::FunctionNonMainContext { func_name } => Diagnostic::simple_error( - "cannot call function outside of main".to_owned(), - format!("function {func_name} can only be called in main"), - span, - ), } } } diff --git a/crates/noirc_evaluator/src/lib.rs b/crates/noirc_evaluator/src/lib.rs index c7d4f5baed6..f5403e1cf49 100644 --- a/crates/noirc_evaluator/src/lib.rs +++ b/crates/noirc_evaluator/src/lib.rs @@ -7,8 +7,8 @@ mod errors; // SSA code to create the SSA based IR // for functions and execute different optimizations. -pub mod ssa_refactor; +pub mod ssa; pub mod brillig; -pub use ssa_refactor::create_circuit; +pub use ssa::create_circuit; diff --git a/crates/noirc_evaluator/src/ssa_refactor.rs b/crates/noirc_evaluator/src/ssa.rs similarity index 82% rename from crates/noirc_evaluator/src/ssa_refactor.rs rename to crates/noirc_evaluator/src/ssa.rs index fa3b7f05a86..2b7be935619 100644 --- a/crates/noirc_evaluator/src/ssa_refactor.rs +++ b/crates/noirc_evaluator/src/ssa.rs @@ -35,7 +35,6 @@ pub mod ssa_gen; /// convert the final SSA into ACIR and return it. pub(crate) fn optimize_into_acir( program: Program, - allow_log_ops: bool, print_ssa_passes: bool, print_brillig_trace: bool, ) -> Result { @@ -63,24 +62,28 @@ pub(crate) fn optimize_into_acir( .dead_instruction_elimination() .print(print_ssa_passes, "After Dead Instruction Elimination:"); } - ssa.into_acir(brillig, abi_distinctness, allow_log_ops) + ssa.into_acir(brillig, abi_distinctness) } -/// Compiles the Program into ACIR and applies optimizations to the arithmetic gates -/// This is analogous to `ssa:create_circuit` and this method is called when one wants -/// to use the new ssa module to process Noir code. -// TODO: This no longer needs to return a result, but it is kept to match the signature of `create_circuit` +/// Compiles the [`Program`] into [`ACIR`][acvm::acir::circuit::Circuit]. +/// +/// The output ACIR is is backend-agnostic and so must go through a transformation pass before usage in proof generation. pub fn create_circuit( program: Program, enable_ssa_logging: bool, enable_brillig_logging: bool, - show_output: bool, ) -> Result<(Circuit, DebugInfo, Abi), RuntimeError> { let func_sig = program.main_function_signature.clone(); - let GeneratedAcir { current_witness_index, opcodes, return_witnesses, locations, .. } = - optimize_into_acir(program, show_output, enable_ssa_logging, enable_brillig_logging)?; + let GeneratedAcir { + current_witness_index, + opcodes, + return_witnesses, + locations, + input_witnesses, + .. + } = optimize_into_acir(program, enable_ssa_logging, enable_brillig_logging)?; - let abi = gen_abi(func_sig, return_witnesses.clone()); + let abi = gen_abi(func_sig, &input_witnesses, return_witnesses.clone()); let public_abi = abi.clone().public_abi(); let public_parameters = diff --git a/crates/noirc_evaluator/src/ssa_refactor/abi_gen/mod.rs b/crates/noirc_evaluator/src/ssa/abi_gen/mod.rs similarity index 63% rename from crates/noirc_evaluator/src/ssa_refactor/abi_gen/mod.rs rename to crates/noirc_evaluator/src/ssa/abi_gen/mod.rs index db39b1c8110..778d8aba8d5 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/abi_gen/mod.rs +++ b/crates/noirc_evaluator/src/ssa/abi_gen/mod.rs @@ -1,14 +1,18 @@ use std::collections::BTreeMap; use acvm::acir::native_types::Witness; -use iter_extended::{btree_map, vecmap}; +use iter_extended::btree_map; use noirc_abi::{Abi, AbiParameter, FunctionSignature}; /// Arranges a function signature and a generated circuit's return witnesses into a /// `noirc_abi::Abi`. -pub(crate) fn gen_abi(func_sig: FunctionSignature, return_witnesses: Vec) -> Abi { +pub(crate) fn gen_abi( + func_sig: FunctionSignature, + input_witnesses: &[Witness], + return_witnesses: Vec, +) -> Abi { let (parameters, return_type) = func_sig; - let param_witnesses = param_witnesses_from_abi_param(¶meters); + let param_witnesses = param_witnesses_from_abi_param(¶meters, input_witnesses); Abi { parameters, return_type, param_witnesses, return_witnesses } } @@ -16,14 +20,17 @@ pub(crate) fn gen_abi(func_sig: FunctionSignature, return_witnesses: Vec, + input_witnesses: &[Witness], ) -> BTreeMap> { - let mut offset = 1; + let mut idx = 0_usize; + btree_map(abi_params, |param| { let num_field_elements_needed = param.typ.field_count(); - let idx_start = offset; - let idx_end = idx_start + num_field_elements_needed; - let witnesses = vecmap(idx_start..idx_end, Witness); - offset += num_field_elements_needed; - (param.name.clone(), witnesses) + let mut wit = Vec::new(); + for _ in 0..num_field_elements_needed { + wit.push(input_witnesses[idx]); + idx += 1; + } + (param.name.clone(), wit) }) } diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir.rs b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs similarity index 78% rename from crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir.rs rename to crates/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs index 6e715002161..96800b22ad0 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs @@ -1,4 +1,3 @@ pub(crate) mod acir_variable; -pub(crate) mod errors; pub(crate) mod generated_acir; pub(crate) mod sort; diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/acir_variable.rs b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs similarity index 84% rename from crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/acir_variable.rs rename to crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs index 2fdfb0bd10f..779aaa559ed 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/acir_variable.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs @@ -1,15 +1,15 @@ -use super::{errors::AcirGenError, generated_acir::GeneratedAcir}; +use super::generated_acir::GeneratedAcir; use crate::brillig::brillig_gen::brillig_directive; -use crate::ssa_refactor::acir_gen::{AcirDynamicArray, AcirValue}; -use crate::ssa_refactor::ir::types::Type as SsaType; -use crate::ssa_refactor::ir::{instruction::Endian, types::NumericType}; +use crate::errors::{InternalError, RuntimeError}; +use crate::ssa::acir_gen::{AcirDynamicArray, AcirValue}; +use crate::ssa::ir::types::Type as SsaType; +use crate::ssa::ir::{instruction::Endian, types::NumericType}; use acvm::acir::circuit::opcodes::{BlockId, MemOp}; use acvm::acir::circuit::Opcode; use acvm::acir::{ brillig::Opcode as BrilligOpcode, circuit::brillig::{BrilligInputs, BrilligOutputs}, }; - use acvm::{ acir::{ circuit::opcodes::FunctionInput, @@ -18,7 +18,7 @@ use acvm::{ }, FieldElement, }; -use iter_extended::vecmap; +use iter_extended::{try_vecmap, vecmap}; use noirc_errors::Location; use std::collections::HashMap; use std::{borrow::Cow, hash::Hash}; @@ -55,6 +55,11 @@ impl AcirType { } } + /// Returns a field type + pub(crate) fn field() -> Self { + AcirType::NumericType(NumericType::NativeField) + } + /// Returns a boolean type fn boolean() -> Self { AcirType::NumericType(NumericType::Unsigned { bit_size: 1 }) @@ -110,6 +115,26 @@ pub(crate) struct AcirContext { } impl AcirContext { + pub(crate) fn current_witness_index(&self) -> Witness { + self.acir_ir.current_witness_index() + } + + pub(crate) fn extract_witness(&self, inputs: &[AcirValue]) -> Vec { + inputs + .iter() + .flat_map(|value| value.clone().flatten()) + .map(|value| { + self.vars + .get(&value.0) + .expect("ICE: undeclared AcirVar") + .to_expression() + .to_witness() + .expect("ICE - cannot extract a witness") + .0 + }) + .collect() + } + /// Adds a constant to the context and assigns a Variable to represent it pub(crate) fn add_constant(&mut self, constant: FieldElement) -> AcirVar { let constant_data = AcirVarData::Const(constant); @@ -162,7 +187,7 @@ impl AcirContext { &mut self, var: AcirVar, predicate: AcirVar, - ) -> Result { + ) -> Result { let var_data = &self.vars[&var]; if let AcirVarData::Const(constant) = var_data { // Note that this will return a 0 if the inverse is not available @@ -179,7 +204,7 @@ impl AcirContext { inverse_code, vec![AcirValue::Var(var, field_type.clone())], vec![field_type], - ); + )?; let inverted_var = Self::expect_one_var(results); let should_be_one = self.mul_var(inverted_var, var)?; @@ -189,7 +214,7 @@ impl AcirContext { } // Constrains `var` to be equal to the constant value `1` - pub(crate) fn assert_eq_one(&mut self, var: AcirVar) -> Result<(), AcirGenError> { + pub(crate) fn assert_eq_one(&mut self, var: AcirVar) -> Result<(), RuntimeError> { let one = self.add_constant(FieldElement::one()); self.assert_eq_var(var, one) } @@ -202,7 +227,7 @@ impl AcirContext { &mut self, var: AcirVar, predicate: AcirVar, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { let pred_mul_var = self.mul_var(var, predicate)?; self.assert_eq_var(pred_mul_var, predicate) } @@ -220,7 +245,7 @@ impl AcirContext { /// Returns an `AcirVar` that is `1` if `lhs` equals `rhs` and /// 0 otherwise. - pub(crate) fn eq_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { + pub(crate) fn eq_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; @@ -238,9 +263,9 @@ impl AcirContext { lhs: AcirVar, rhs: AcirVar, typ: AcirType, - ) -> Result { + ) -> Result { let inputs = vec![AcirValue::Var(lhs, typ.clone()), AcirValue::Var(rhs, typ)]; - let outputs = self.black_box_function(BlackBoxFunc::XOR, inputs)?; + let outputs = self.black_box_function(BlackBoxFunc::XOR, inputs, 1)?; Ok(outputs[0]) } @@ -250,9 +275,9 @@ impl AcirContext { lhs: AcirVar, rhs: AcirVar, typ: AcirType, - ) -> Result { + ) -> Result { let inputs = vec![AcirValue::Var(lhs, typ.clone()), AcirValue::Var(rhs, typ)]; - let outputs = self.black_box_function(BlackBoxFunc::AND, inputs)?; + let outputs = self.black_box_function(BlackBoxFunc::AND, inputs, 1)?; Ok(outputs[0]) } @@ -262,7 +287,7 @@ impl AcirContext { lhs: AcirVar, rhs: AcirVar, typ: AcirType, - ) -> Result { + ) -> Result { let bit_size = typ.bit_size(); if bit_size == 1 { // Operands are booleans @@ -279,13 +304,13 @@ impl AcirContext { let a = self.sub_var(max, lhs)?; let b = self.sub_var(max, rhs)?; let inputs = vec![AcirValue::Var(a, typ.clone()), AcirValue::Var(b, typ)]; - let outputs = self.black_box_function(BlackBoxFunc::AND, inputs)?; + let outputs = self.black_box_function(BlackBoxFunc::AND, inputs, 1)?; self.sub_var(max, outputs[0]) } } /// Constrains the `lhs` and `rhs` to be equal. - pub(crate) fn assert_eq_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result<(), AcirGenError> { + pub(crate) fn assert_eq_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result<(), RuntimeError> { // TODO: could use sub_var and then assert_eq_zero let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; @@ -296,7 +321,7 @@ impl AcirContext { Ok(()) } else { // Constraint is always false - this program is unprovable - Err(AcirGenError::BadConstantEquality { + Err(RuntimeError::FailedConstraint { lhs: *lhs_const, rhs: *rhs_const, location: self.get_location(), @@ -318,7 +343,7 @@ impl AcirContext { rhs: AcirVar, typ: AcirType, predicate: AcirVar, - ) -> Result { + ) -> Result { let numeric_type = match typ { AcirType::NumericType(numeric_type) => numeric_type, AcirType::Array(_, _) => { @@ -345,7 +370,7 @@ impl AcirContext { /// Adds a new Variable to context whose value will /// be constrained to be the multiplication of `lhs` and `rhs` - pub(crate) fn mul_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { + pub(crate) fn mul_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; let result = match (lhs_data, rhs_data) { @@ -392,14 +417,14 @@ impl AcirContext { /// Adds a new Variable to context whose value will /// be constrained to be the subtraction of `lhs` and `rhs` - pub(crate) fn sub_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { + pub(crate) fn sub_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { let neg_rhs = self.neg_var(rhs); self.add_var(lhs, neg_rhs) } /// Adds a new Variable to context whose value will /// be constrained to be the addition of `lhs` and `rhs` - pub(crate) fn add_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { + pub(crate) fn add_var(&mut self, lhs: AcirVar, rhs: AcirVar) -> Result { let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; let result_data = if let (AcirVarData::Const(lhs_const), AcirVarData::Const(rhs_const)) = @@ -414,7 +439,7 @@ impl AcirContext { } /// Adds a new variable that is constrained to be the logical NOT of `x`. - pub(crate) fn not_var(&mut self, x: AcirVar, typ: AcirType) -> Result { + pub(crate) fn not_var(&mut self, x: AcirVar, typ: AcirType) -> Result { let bit_size = typ.bit_size(); // Subtracting from max flips the bits let max = self.add_constant(FieldElement::from((1_u128 << bit_size) - 1)); @@ -433,7 +458,7 @@ impl AcirContext { lhs: AcirVar, rhs: AcirVar, _typ: AcirType, - ) -> Result { + ) -> Result { let rhs_data = &self.vars[&rhs]; // Compute 2^{rhs} @@ -453,7 +478,7 @@ impl AcirContext { rhs: AcirVar, bit_size: u32, predicate: AcirVar, - ) -> Result<(AcirVar, AcirVar), AcirGenError> { + ) -> Result<(AcirVar, AcirVar), RuntimeError> { let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; let predicate_data = &self.vars[&predicate]; @@ -485,7 +510,7 @@ impl AcirContext { lhs: AcirVar, rhs: AcirVar, bit_size: u32, - ) -> Result<(AcirVar, AcirVar), AcirGenError> { + ) -> Result<(AcirVar, AcirVar), RuntimeError> { let lhs_data = &self.vars[&lhs].clone(); let rhs_data = &self.vars[&rhs].clone(); @@ -509,7 +534,7 @@ impl AcirContext { rhs: AcirVar, bit_size: u32, predicate: AcirVar, - ) -> Result { + ) -> Result { let (_, remainder) = self.euclidean_division_var(lhs, rhs, bit_size, predicate)?; Ok(remainder) } @@ -530,7 +555,7 @@ impl AcirContext { rhs: AcirVar, typ: AcirType, predicate: AcirVar, - ) -> Result { + ) -> Result { let rhs_data = &self.vars[&rhs]; // Compute 2^{rhs} @@ -545,8 +570,11 @@ impl AcirContext { /// Converts the `AcirVar` to a `Witness` if it hasn't been already, and appends it to the /// `GeneratedAcir`'s return witnesses. - pub(crate) fn return_var(&mut self, acir_var: AcirVar) { - let acir_var_data = self.vars.get(&acir_var).expect("ICE: return of undeclared AcirVar"); + pub(crate) fn return_var(&mut self, acir_var: AcirVar) -> Result<(), InternalError> { + let acir_var_data = match self.vars.get(&acir_var) { + Some(acir_var_data) => acir_var_data, + None => return Err(InternalError::UndeclaredAcirVar { location: self.get_location() }), + }; // TODO: Add caching to prevent expressions from being needlessly duplicated let witness = match acir_var_data { AcirVarData::Const(constant) => { @@ -556,6 +584,7 @@ impl AcirContext { AcirVarData::Witness(witness) => *witness, }; self.acir_ir.push_return_witness(witness); + Ok(()) } /// Constrains the `AcirVar` variable to be of type `NumericType`. @@ -563,7 +592,7 @@ impl AcirContext { &mut self, variable: AcirVar, numeric_type: &NumericType, - ) -> Result { + ) -> Result { let data = &self.vars[&variable]; match numeric_type { NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size } => { @@ -579,12 +608,14 @@ impl AcirContext { } /// Returns an `AcirVar` which will be constrained to be lhs mod 2^{rhs} + /// In order to do this, we simply perform euclidian division of lhs by 2^{rhs} + /// The remainder of the division is then lhs mod 2^{rhs} pub(crate) fn truncate_var( &mut self, lhs: AcirVar, rhs: u32, max_bit_size: u32, - ) -> Result { + ) -> Result { let lhs_data = &self.vars[&lhs]; let lhs_expr = lhs_data.to_expression(); @@ -609,7 +640,7 @@ impl AcirContext { rhs: AcirVar, bit_size: u32, predicate: AcirVar, - ) -> Result { + ) -> Result { let lhs_data = &self.vars[&lhs]; let rhs_data = &self.vars[&rhs]; @@ -636,7 +667,7 @@ impl AcirContext { rhs: AcirVar, bit_size: u32, predicate: AcirVar, - ) -> Result { + ) -> Result { // Flip the result of calling more than equal method to // compute less than. let comparison = self.more_than_eq_var(lhs, rhs, bit_size, predicate)?; @@ -651,17 +682,32 @@ impl AcirContext { &mut self, name: BlackBoxFunc, mut inputs: Vec, - ) -> Result, AcirGenError> { + output_count: usize, + ) -> Result, RuntimeError> { // Separate out any arguments that should be constants let constants = match name { BlackBoxFunc::Pedersen => { // The last argument of pedersen is the domain separator, which must be a constant - let domain_var = - inputs.pop().expect("ICE: Pedersen call requires domain separator").into_var(); - - let domain_constant = self.vars[&domain_var] - .as_constant() - .expect("ICE: Domain separator must be a constant"); + let domain_var = match inputs.pop() { + Some(domain_var) => domain_var.into_var()?, + None => { + return Err(RuntimeError::InternalError(InternalError::MissingArg { + name: "pedersen call".to_string(), + arg: "domain separator".to_string(), + location: self.get_location(), + })) + } + }; + + let domain_constant = match self.vars[&domain_var].as_constant() { + Some(domain_constant) => domain_constant, + None => { + return Err(RuntimeError::InternalError(InternalError::NotAConstant { + name: "domain separator".to_string(), + location: self.get_location(), + })) + } + }; vec![domain_constant] } @@ -672,7 +718,7 @@ impl AcirContext { let inputs = self.prepare_inputs_for_black_box_func_call(inputs)?; // Call Black box with `FunctionInput` - let outputs = self.acir_ir.call_black_box(name, inputs, constants); + let outputs = self.acir_ir.call_black_box(name, &inputs, constants, output_count)?; // Convert `Witness` values which are now constrained to be the output of the // black box function call into `AcirVar`s. @@ -688,9 +734,10 @@ impl AcirContext { fn prepare_inputs_for_black_box_func_call( &mut self, inputs: Vec, - ) -> Result, AcirGenError> { + ) -> Result>, RuntimeError> { let mut witnesses = Vec::new(); for input in inputs { + let mut single_val_witnesses = Vec::new(); for (input, typ) in input.flatten() { let var_data = &self.vars[&input]; @@ -700,8 +747,9 @@ impl AcirContext { let expr = var_data.to_expression(); let witness = self.acir_ir.get_or_create_witness(&expr); let num_bits = typ.bit_size(); - witnesses.push(FunctionInput { witness, num_bits }); + single_val_witnesses.push(FunctionInput { witness, num_bits }); } + witnesses.push(single_val_witnesses); } Ok(witnesses) } @@ -719,15 +767,26 @@ impl AcirContext { radix_var: AcirVar, limb_count_var: AcirVar, result_element_type: AcirType, - ) -> Result, AcirGenError> { - let radix = - self.vars[&radix_var].as_constant().expect("ICE: radix should be a constant").to_u128() - as u32; + ) -> Result, RuntimeError> { + let radix = match self.vars[&radix_var].as_constant() { + Some(radix) => radix.to_u128() as u32, + None => { + return Err(RuntimeError::InternalError(InternalError::NotAConstant { + name: "radix".to_string(), + location: self.get_location(), + })); + } + }; - let limb_count = self.vars[&limb_count_var] - .as_constant() - .expect("ICE: limb_size should be a constant") - .to_u128() as u32; + let limb_count = match self.vars[&limb_count_var].as_constant() { + Some(limb_count) => limb_count.to_u128() as u32, + None => { + return Err(RuntimeError::InternalError(InternalError::NotAConstant { + name: "limb_size".to_string(), + location: self.get_location(), + })); + } + }; let input_expr = &self.vars[&input_var].to_expression(); @@ -763,24 +822,11 @@ impl AcirContext { input_var: AcirVar, limb_count_var: AcirVar, result_element_type: AcirType, - ) -> Result, AcirGenError> { + ) -> Result, RuntimeError> { let two_var = self.add_constant(FieldElement::from(2_u128)); self.radix_decompose(endian, input_var, two_var, limb_count_var, result_element_type) } - /// Prints the given `AcirVar`s as witnesses. - pub(crate) fn print(&mut self, input: Vec) -> Result<(), AcirGenError> { - let input = Self::flatten_values(input); - - let witnesses = vecmap(input, |acir_var| { - let var_data = &self.vars[&acir_var]; - let expr = var_data.to_expression(); - self.acir_ir.get_or_create_witness(&expr) - }); - self.acir_ir.call_print(witnesses); - Ok(()) - } - /// Flatten the given Vector of AcirValues into a single vector of only variables. /// Each AcirValue::Array in the vector is recursively flattened, so each element /// will flattened into the resulting Vec. E.g. flatten_values([1, [2, 3]) == [1, 2, 3]. @@ -806,7 +852,8 @@ impl AcirContext { } /// Terminates the context and takes the resulting `GeneratedAcir` - pub(crate) fn finish(self) -> GeneratedAcir { + pub(crate) fn finish(mut self, inputs: Vec) -> GeneratedAcir { + self.acir_ir.input_witnesses = vecmap(inputs, Witness); self.acir_ir } @@ -827,24 +874,24 @@ impl AcirContext { code: Vec, inputs: Vec, outputs: Vec, - ) -> Vec { - let b_inputs = vecmap(inputs, |i| match i { + ) -> Result, InternalError> { + let b_inputs = try_vecmap(inputs, |i| match i { AcirValue::Var(var, _) => { - BrilligInputs::Single(self.vars[&var].to_expression().into_owned()) + Ok(BrilligInputs::Single(self.vars[&var].to_expression().into_owned())) } AcirValue::Array(vars) => { let mut var_expressions: Vec = Vec::new(); for var in vars { - self.brillig_array_input(&mut var_expressions, var); + self.brillig_array_input(&mut var_expressions, var)?; } - BrilligInputs::Array(var_expressions) + Ok(BrilligInputs::Array(var_expressions)) } AcirValue::DynamicArray(_) => { let mut var_expressions = Vec::new(); - self.brillig_array_input(&mut var_expressions, i); - BrilligInputs::Array(var_expressions) + self.brillig_array_input(&mut var_expressions, i)?; + Ok(BrilligInputs::Array(var_expressions)) } - }); + })?; let mut b_outputs = Vec::new(); let outputs_var = vecmap(outputs, |output| match output { @@ -863,17 +910,21 @@ impl AcirContext { let predicate = self.vars[&predicate].to_expression().into_owned(); self.acir_ir.brillig(Some(predicate), code, b_inputs, b_outputs); - outputs_var + Ok(outputs_var) } - fn brillig_array_input(&mut self, var_expressions: &mut Vec, input: AcirValue) { + fn brillig_array_input( + &mut self, + var_expressions: &mut Vec, + input: AcirValue, + ) -> Result<(), InternalError> { match input { AcirValue::Var(var, _) => { var_expressions.push(self.vars[&var].to_expression().into_owned()); } AcirValue::Array(vars) => { for var in vars { - self.brillig_array_input(var_expressions, var); + self.brillig_array_input(var_expressions, var)?; } } AcirValue::DynamicArray(AcirDynamicArray { block_id, len }) => { @@ -883,18 +934,19 @@ impl AcirContext { self.add_constant(FieldElement::from(i as u128)), AcirType::NumericType(NumericType::NativeField), ); - let index_var = index.into_var(); + let index_var = index.into_var()?; - let value_read_var = self.read_from_memory(block_id, &index_var); + let value_read_var = self.read_from_memory(block_id, &index_var)?; let value_read = AcirValue::Var( value_read_var, AcirType::NumericType(NumericType::NativeField), ); - self.brillig_array_input(var_expressions, value_read); + self.brillig_array_input(var_expressions, value_read)?; } } } + Ok(()) } /// Recursively create acir values for returned arrays. This is necessary because a brillig returned array can have nested arrays as elements. @@ -936,7 +988,7 @@ impl AcirContext { inputs: Vec, bit_size: u32, predicate: AcirVar, - ) -> Result, AcirGenError> { + ) -> Result, RuntimeError> { let len = inputs.len(); // Convert the inputs into expressions let inputs_expr = vecmap(inputs, |input| self.vars[&input].to_expression().into_owned()); @@ -949,7 +1001,7 @@ impl AcirContext { }); // Enforce the outputs to be a permutation of the inputs - self.acir_ir.permutation(&inputs_expr, &output_expr); + self.acir_ir.permutation(&inputs_expr, &output_expr)?; // Enforce the outputs to be sorted for i in 0..(outputs_var.len() - 1) { @@ -959,9 +1011,12 @@ impl AcirContext { Ok(outputs_var) } /// Converts an AcirVar to a Witness - fn var_to_witness(&mut self, var: AcirVar) -> Witness { - let var_data = self.vars.get(&var).expect("ICE: undeclared AcirVar"); - self.acir_ir.get_or_create_witness(&var_data.to_expression()) + fn var_to_witness(&mut self, var: AcirVar) -> Result { + let var_data = match self.vars.get(&var) { + Some(var_data) => var_data, + None => return Err(InternalError::UndeclaredAcirVar { location: self.get_location() }), + }; + Ok(self.acir_ir.get_or_create_witness(&var_data.to_expression())) } /// Constrain lhs to be less than rhs @@ -971,40 +1026,50 @@ impl AcirContext { rhs: AcirVar, bit_size: u32, predicate: AcirVar, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { let lhs_less_than_rhs = self.more_than_eq_var(rhs, lhs, bit_size, predicate)?; self.maybe_eq_predicate(lhs_less_than_rhs, predicate) } /// Returns a Variable that is constrained to be the result of reading /// from the memory `block_id` at the given `index`. - pub(crate) fn read_from_memory(&mut self, block_id: BlockId, index: &AcirVar) -> AcirVar { + pub(crate) fn read_from_memory( + &mut self, + block_id: BlockId, + index: &AcirVar, + ) -> Result { // Fetch the witness corresponding to the index - let index_witness = self.var_to_witness(*index); + let index_witness = self.var_to_witness(*index)?; // Create a Variable to hold the result of the read and extract the corresponding Witness let value_read_var = self.add_variable(); - let value_read_witness = self.var_to_witness(value_read_var); + let value_read_witness = self.var_to_witness(value_read_var)?; // Add the memory read operation to the list of opcodes let op = MemOp::read_at_mem_index(index_witness.into(), value_read_witness); self.acir_ir.opcodes.push(Opcode::MemoryOp { block_id, op }); - value_read_var + Ok(value_read_var) } /// Constrains the Variable `value` to be the new value located at `index` in the memory `block_id`. - pub(crate) fn write_to_memory(&mut self, block_id: BlockId, index: &AcirVar, value: &AcirVar) { + pub(crate) fn write_to_memory( + &mut self, + block_id: BlockId, + index: &AcirVar, + value: &AcirVar, + ) -> Result<(), InternalError> { // Fetch the witness corresponding to the index // - let index_witness = self.var_to_witness(*index); + let index_witness = self.var_to_witness(*index)?; // Fetch the witness corresponding to the value to be written - let value_write_witness = self.var_to_witness(*value); + let value_write_witness = self.var_to_witness(*value)?; // Add the memory write operation to the list of opcodes let op = MemOp::write_to_mem_index(index_witness.into(), value_write_witness.into()); self.acir_ir.opcodes.push(Opcode::MemoryOp { block_id, op }); + Ok(()) } /// Initializes an array in memory with the given values `optional_values`. @@ -1014,22 +1079,23 @@ impl AcirContext { block_id: BlockId, len: usize, optional_values: Option<&[AcirValue]>, - ) { + ) -> Result<(), InternalError> { // If the optional values are supplied, then we fill the initialized // array with those values. If not, then we fill it with zeros. let initialized_values = match optional_values { None => { let zero = self.add_constant(FieldElement::zero()); - let zero_witness = self.var_to_witness(zero); + let zero_witness = self.var_to_witness(zero)?; vec![zero_witness; len] } - Some(optional_values) => vecmap(optional_values, |value| { - let value = value.clone().into_var(); + Some(optional_values) => try_vecmap(optional_values, |value| { + let value = value.clone().into_var()?; self.var_to_witness(value) - }), + })?, }; self.acir_ir.opcodes.push(Opcode::MemoryInit { block_id, init: initialized_values }); + Ok(()) } } diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/generated_acir.rs b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs similarity index 75% rename from crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/generated_acir.rs rename to crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs index 18c7216a6fa..b425eab42d3 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/generated_acir.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs @@ -2,14 +2,16 @@ //! program as it is being converted from SSA form. use std::collections::HashMap; -use crate::brillig::brillig_gen::brillig_directive; +use crate::{ + brillig::brillig_gen::brillig_directive, + errors::{InternalError, RuntimeError}, +}; -use super::errors::AcirGenError; use acvm::acir::{ brillig::Opcode as BrilligOpcode, circuit::{ brillig::{Brillig as AcvmBrillig, BrilligInputs, BrilligOutputs}, - directives::{LogInfo, QuotientDirective}, + directives::LogInfo, opcodes::{BlackBoxFuncCall, FunctionInput, Opcode as AcirOpcode}, }, native_types::Witness, @@ -40,6 +42,9 @@ pub(crate) struct GeneratedAcir { /// abi's return type. pub(crate) return_witnesses: Vec, + /// All witness indices which are inputs to the main function + pub(crate) input_witnesses: Vec, + /// Correspondance between an opcode index (in opcodes) and the source code location which generated it pub(crate) locations: HashMap, @@ -117,12 +122,14 @@ impl GeneratedAcir { pub(crate) fn call_black_box( &mut self, func_name: BlackBoxFunc, - mut inputs: Vec, + inputs: &[Vec], constants: Vec, - ) -> Vec { - intrinsics_check_inputs(func_name, &inputs); + output_count: usize, + ) -> Result, InternalError> { + let input_count = inputs.iter().fold(0usize, |sum, val| sum + val.len()); + intrinsics_check_inputs(func_name, input_count); + intrinsics_check_outputs(func_name, output_count); - let output_count = black_box_expected_output_size(func_name); let outputs = vecmap(0..output_count, |_| self.next_witness_index()); // clone is needed since outputs is moved when used in blackbox function. @@ -130,67 +137,99 @@ impl GeneratedAcir { let black_box_func_call = match func_name { BlackBoxFunc::AND => { - BlackBoxFuncCall::AND { lhs: inputs[0], rhs: inputs[1], output: outputs[0] } + BlackBoxFuncCall::AND { lhs: inputs[0][0], rhs: inputs[1][0], output: outputs[0] } } BlackBoxFunc::XOR => { - BlackBoxFuncCall::XOR { lhs: inputs[0], rhs: inputs[1], output: outputs[0] } + BlackBoxFuncCall::XOR { lhs: inputs[0][0], rhs: inputs[1][0], output: outputs[0] } } - BlackBoxFunc::RANGE => BlackBoxFuncCall::RANGE { input: inputs[0] }, - BlackBoxFunc::SHA256 => BlackBoxFuncCall::SHA256 { inputs, outputs }, - BlackBoxFunc::Blake2s => BlackBoxFuncCall::Blake2s { inputs, outputs }, - BlackBoxFunc::HashToField128Security => { - BlackBoxFuncCall::HashToField128Security { inputs, output: outputs[0] } + BlackBoxFunc::RANGE => BlackBoxFuncCall::RANGE { input: inputs[0][0] }, + BlackBoxFunc::SHA256 => BlackBoxFuncCall::SHA256 { inputs: inputs[0].clone(), outputs }, + BlackBoxFunc::Blake2s => { + BlackBoxFuncCall::Blake2s { inputs: inputs[0].clone(), outputs } } + BlackBoxFunc::HashToField128Security => BlackBoxFuncCall::HashToField128Security { + inputs: inputs[0].clone(), + output: outputs[0], + }, BlackBoxFunc::SchnorrVerify => BlackBoxFuncCall::SchnorrVerify { - public_key_x: inputs[0], - public_key_y: inputs[1], + public_key_x: inputs[0][0], + public_key_y: inputs[1][0], // Schnorr signature is an r & s, 32 bytes each - signature: inputs[2..66].to_vec(), - message: inputs[66..].to_vec(), + signature: inputs[2].clone(), + message: inputs[3].clone(), output: outputs[0], }, BlackBoxFunc::Pedersen => BlackBoxFuncCall::Pedersen { - inputs, + inputs: inputs[0].clone(), outputs: (outputs[0], outputs[1]), domain_separator: constants[0].to_u128() as u32, }, BlackBoxFunc::EcdsaSecp256k1 => BlackBoxFuncCall::EcdsaSecp256k1 { // 32 bytes for each public key co-ordinate - public_key_x: inputs[0..32].to_vec(), - public_key_y: inputs[32..64].to_vec(), + public_key_x: inputs[0].clone(), + public_key_y: inputs[1].clone(), // (r,s) are both 32 bytes each, so signature // takes up 64 bytes - signature: inputs[64..128].to_vec(), - hashed_message: inputs[128..].to_vec(), + signature: inputs[2].clone(), + hashed_message: inputs[3].clone(), output: outputs[0], }, BlackBoxFunc::EcdsaSecp256r1 => BlackBoxFuncCall::EcdsaSecp256r1 { // 32 bytes for each public key co-ordinate - public_key_x: inputs[0..32].to_vec(), - public_key_y: inputs[32..64].to_vec(), + public_key_x: inputs[0].clone(), + public_key_y: inputs[1].clone(), // (r,s) are both 32 bytes each, so signature // takes up 64 bytes - signature: inputs[64..128].to_vec(), - hashed_message: inputs[128..].to_vec(), + signature: inputs[2].clone(), + hashed_message: inputs[3].clone(), output: outputs[0], }, BlackBoxFunc::FixedBaseScalarMul => BlackBoxFuncCall::FixedBaseScalarMul { - input: inputs[0], + input: inputs[0][0], outputs: (outputs[0], outputs[1]), }, BlackBoxFunc::Keccak256 => { - let var_message_size = inputs.pop().expect("ICE: Missing message_size arg"); - BlackBoxFuncCall::Keccak256VariableLength { inputs, var_message_size, outputs } + let var_message_size = match inputs.to_vec().pop() { + Some(var_message_size) => var_message_size[0], + None => { + return Err(InternalError::MissingArg { + name: "".to_string(), + arg: "message_size".to_string(), + location: self.current_location, + }); + } + }; + BlackBoxFuncCall::Keccak256VariableLength { + inputs: inputs[0].clone(), + var_message_size, + outputs, + } } - // TODO(#1570): Generate ACIR for recursive aggregation BlackBoxFunc::RecursiveAggregation => { - panic!("ICE: Cannot generate ACIR for recursive aggregation") + let has_previous_aggregation = self.opcodes.iter().any(|op| { + matches!( + op, + AcirOpcode::BlackBoxFuncCall(BlackBoxFuncCall::RecursiveAggregation { .. }) + ) + }); + + let input_aggregation_object = + if !has_previous_aggregation { None } else { Some(inputs[4].clone()) }; + + BlackBoxFuncCall::RecursiveAggregation { + verification_key: inputs[0].clone(), + proof: inputs[1].clone(), + public_inputs: inputs[2].clone(), + key_hash: inputs[3][0], + input_aggregation_object, + output_aggregation_object: outputs, + } } }; self.opcodes.push(AcirOpcode::BlackBoxFuncCall(black_box_func_call)); - outputs_clone + Ok(outputs_clone) } /// Takes an input expression and returns witnesses that are constrained to be limbs @@ -203,7 +242,7 @@ impl GeneratedAcir { radix: u32, limb_count: u32, bit_size: u32, - ) -> Result, AcirGenError> { + ) -> Result, RuntimeError> { let radix_big = BigUint::from(radix); assert_eq!( BigUint::from(2u128).pow(bit_size), @@ -248,8 +287,11 @@ impl GeneratedAcir { ) -> Expression { let max_power_of_two = FieldElement::from(2_i128).pow(&FieldElement::from(max_bit_size as i128 - 1)); - let inter = &(&Expression::from_field(max_power_of_two) - lhs) * &leading.into(); - lhs.add_mul(FieldElement::from(2_i128), &inter.unwrap()) + + let intermediate = + self.mul_with_witness(&(&Expression::from(max_power_of_two) - lhs), &leading.into()); + + lhs.add_mul(FieldElement::from(2_i128), &intermediate) } /// Returns an expression which represents `lhs * rhs` @@ -257,7 +299,7 @@ impl GeneratedAcir { /// If one has multiplicative term and the other is of degree one or more, /// the function creates [intermediate variables][`Witness`] accordingly. /// There are two cases where we can optimize the multiplication between two expressions: - /// 1. If both expressions have at most a total degree of 1 in each term, then we can just multiply them + /// 1. If the sum of the degrees of both expressions is at most 2, then we can just multiply them /// as each term in the result will be degree-2. /// 2. If one expression is a constant, then we can just multiply the constant with the other expression /// @@ -268,10 +310,14 @@ impl GeneratedAcir { let lhs_is_linear = lhs.is_linear(); let rhs_is_linear = rhs.is_linear(); - // Case 1: Both expressions have at most a total degree of 1 in each term - if lhs_is_linear && rhs_is_linear { - return (lhs * rhs) - .expect("one of the expressions is a constant and so this should not fail"); + // Case 1: The sum of the degrees of both expressions is at most 2. + // + // If one of the expressions is constant then it does not increase the degree when multiplying by another expression. + // If both of the expressions are linear (degree <=1) then the product will be at most degree 2. + let both_are_linear = lhs_is_linear && rhs_is_linear; + let either_is_const = lhs.is_const() || rhs.is_const(); + if both_are_linear || either_is_const { + return (lhs * rhs).expect("Both expressions are degree <= 1"); } // Case 2: One or both of the sides needs to be reduced to a degree-1 univariate polynomial @@ -285,7 +331,7 @@ impl GeneratedAcir { // rhs, we only need to square the lhs. if lhs == rhs { return (&*lhs_reduced * &*lhs_reduced) - .expect("Both expressions are reduced to be degree<=1"); + .expect("Both expressions are reduced to be degree <= 1"); }; let rhs_reduced = if rhs_is_linear { @@ -294,7 +340,7 @@ impl GeneratedAcir { Cow::Owned(self.get_or_create_witness(rhs).into()) }; - (&*lhs_reduced * &*rhs_reduced).expect("Both expressions are reduced to be degree<=1") + (&*lhs_reduced * &*rhs_reduced).expect("Both expressions are reduced to be degree <= 1") } /// Signed division lhs / rhs @@ -310,13 +356,13 @@ impl GeneratedAcir { lhs: &Expression, rhs: &Expression, max_bit_size: u32, - ) -> Result<(Expression, Expression), AcirGenError> { + ) -> Result<(Expression, Expression), RuntimeError> { // 2^{max_bit size-1} let max_power_of_two = FieldElement::from(2_i128).pow(&FieldElement::from(max_bit_size as i128 - 1)); // Get the sign bit of rhs by computing rhs / max_power_of_two - let (rhs_leading, _) = self.euclidean_division( + let (rhs_leading_witness, _) = self.euclidean_division( rhs, &max_power_of_two.into(), max_bit_size, @@ -324,7 +370,7 @@ impl GeneratedAcir { )?; // Get the sign bit of lhs by computing lhs / max_power_of_two - let (lhs_leading, _) = self.euclidean_division( + let (lhs_leading_witness, _) = self.euclidean_division( lhs, &max_power_of_two.into(), max_bit_size, @@ -332,8 +378,8 @@ impl GeneratedAcir { )?; // Signed to unsigned: - let unsigned_lhs = self.two_complement(lhs, lhs_leading, max_bit_size); - let unsigned_rhs = self.two_complement(rhs, rhs_leading, max_bit_size); + let unsigned_lhs = self.two_complement(lhs, lhs_leading_witness, max_bit_size); + let unsigned_rhs = self.two_complement(rhs, rhs_leading_witness, max_bit_size); let unsigned_l_witness = self.get_or_create_witness(&unsigned_lhs); let unsigned_r_witness = self.get_or_create_witness(&unsigned_rhs); @@ -347,13 +393,16 @@ impl GeneratedAcir { // Unsigned to signed: derive q and r from q1,r1 and the signs of lhs and rhs // Quotient sign is lhs sign * rhs sign, whose resulting sign bit is the XOR of the sign bits - let q_sign = (&Expression::from(lhs_leading) + &Expression::from(rhs_leading)).add_mul( - -FieldElement::from(2_i128), - &(&Expression::from(lhs_leading) * &Expression::from(rhs_leading)).unwrap(), - ); + let sign_sum = + &Expression::from(lhs_leading_witness) + &Expression::from(rhs_leading_witness); + let sign_prod = (&Expression::from(lhs_leading_witness) + * &Expression::from(rhs_leading_witness)) + .expect("Product of two witnesses so result is degree 2"); + let q_sign = sign_sum.add_mul(-FieldElement::from(2_i128), &sign_prod); + let q_sign_witness = self.get_or_create_witness(&q_sign); let quotient = self.two_complement(&q1.into(), q_sign_witness, max_bit_size); - let remainder = self.two_complement(&r1.into(), lhs_leading, max_bit_size); + let remainder = self.two_complement(&r1.into(), lhs_leading_witness, max_bit_size); Ok((quotient, remainder)) } @@ -367,7 +416,7 @@ impl GeneratedAcir { rhs: &Expression, max_bit_size: u32, predicate: &Expression, - ) -> Result<(Witness, Witness), AcirGenError> { + ) -> Result<(Witness, Witness), RuntimeError> { // lhs = rhs * q + r // // If predicate is zero, `q_witness` and `r_witness` will be 0 @@ -383,13 +432,13 @@ impl GeneratedAcir { } } - let (q_witness, r_witness) = self.quotient_directive( - lhs.clone(), - rhs.clone(), - Some(predicate.clone()), - max_q_bits, - max_rhs_bits, - )?; + let (q_witness, r_witness) = + self.brillig_quotient(lhs.clone(), rhs.clone(), predicate.clone(), max_bit_size + 1); + + // Apply range constraints to injected witness values. + // Constrains `q` to be 0 <= q < 2^{q_max_bits}, etc. + self.range_constraint(q_witness, max_q_bits)?; + self.range_constraint(r_witness, max_rhs_bits)?; // Constrain r < rhs self.bound_constraint_with_offset(&r_witness.into(), rhs, predicate, max_rhs_bits)?; @@ -408,6 +457,32 @@ impl GeneratedAcir { Ok((q_witness, r_witness)) } + /// Adds a brillig opcode which injects witnesses with values `q = a / b` and `r = a % b`. + /// + /// Suitable range constraints for `q` and `r` must be applied externally. + pub(crate) fn brillig_quotient( + &mut self, + lhs: Expression, + rhs: Expression, + predicate: Expression, + max_bit_size: u32, + ) -> (Witness, Witness) { + // Create the witness for the result + let q_witness = self.next_witness_index(); + let r_witness = self.next_witness_index(); + + let quotient_code = brillig_directive::directive_quotient(max_bit_size); + let inputs = vec![ + BrilligInputs::Single(lhs), + BrilligInputs::Single(rhs), + BrilligInputs::Single(predicate.clone()), + ]; + let outputs = vec![BrilligOutputs::Simple(q_witness), BrilligOutputs::Simple(r_witness)]; + self.brillig(Some(predicate), quotient_code, inputs, outputs); + + (q_witness, r_witness) + } + /// Generate constraints that are satisfied iff /// lhs < rhs , when offset is 1, or /// lhs <= rhs, when offset is 0 @@ -425,7 +500,7 @@ impl GeneratedAcir { rhs: &Expression, offset: &Expression, bits: u32, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { const fn num_bits() -> usize { std::mem::size_of::() * 8 } @@ -625,11 +700,11 @@ impl GeneratedAcir { &mut self, witness: Witness, num_bits: u32, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { // We class this as an error because users should instead // do `as Field`. if num_bits >= FieldElement::max_num_bits() { - return Err(AcirGenError::InvalidRangeConstraint { + return Err(RuntimeError::InvalidRangeConstraint { num_bits: FieldElement::max_num_bits(), location: self.current_location, }); @@ -643,45 +718,31 @@ impl GeneratedAcir { Ok(()) } - /// Adds a directive which injects witnesses with values `q = a / b` and `r = a % b`. - /// - /// Suitable range constraints are also applied to `q` and `r`. - pub(crate) fn quotient_directive( - &mut self, - a: Expression, - b: Expression, - predicate: Option, - q_max_bits: u32, - r_max_bits: u32, - ) -> Result<(Witness, Witness), AcirGenError> { - let q_witness = self.next_witness_index(); - let r_witness = self.next_witness_index(); - - let directive = - Directive::Quotient(QuotientDirective { a, b, q: q_witness, r: r_witness, predicate }); - self.push_opcode(AcirOpcode::Directive(directive)); - - // Apply range constraints to injected witness values. - // Constrains `q` to be 0 <= q < 2^{q_max_bits}, etc. - self.range_constraint(q_witness, q_max_bits)?; - self.range_constraint(r_witness, r_max_bits)?; - - Ok((q_witness, r_witness)) - } - /// Returns a `Witness` that is constrained to be: /// - `1` if lhs >= rhs /// - `0` otherwise /// - /// See [R1CS Workshop - Section 10](https://github.com/mir-protocol/r1cs-workshop/blob/master/workshop.pdf) - /// for an explanation. + /// We essentially computes the sign bit of `b-a` + /// For this we sign-extend `b-a` with `c = 2^{max_bits} - (b - a)`, since both `a` and `b` are less than `2^{max_bits}` + /// Then we get the bit sign of `c`, the 2-complement representation of `(b-a)`, which is a `max_bits+1` integer, + /// by doing the euclidean division `c / 2^{max_bits}` + /// + /// To see why it really works; + /// We first note that `c` is an integer of `(max_bits+1)` bits. Therefore, + /// if `b-a>0`, then `c < 2^{max_bits}`, so the division by `2^{max_bits}` will give `0` + /// If `b-a<=0`, then `c >= 2^{max_bits}`, so the division by `2^{max_bits}` will give `1`. + /// + /// In other words, `1` means `a >= b` and `0` means `b > a`. + /// The important thing here is that `c` does not overflow nor underflow the field; + /// - By construction we have `c >= 0`, so there is no underflow + /// - We assert at the beginning that `2^{max_bits+1}` does not overflow the field, so neither c. pub(crate) fn more_than_eq_comparison( &mut self, a: &Expression, b: &Expression, max_bits: u32, predicate: Expression, - ) -> Result { + ) -> Result { // Ensure that 2^{max_bits + 1} is less than the field size // // TODO: perhaps this should be a user error, instead of an assert @@ -750,7 +811,11 @@ impl GeneratedAcir { /// /// n.b. A sorting network is a predetermined set of switches, /// the control bits indicate the configuration of each switch: false for pass-through and true for cross-over - pub(crate) fn permutation(&mut self, in_expr: &[Expression], out_expr: &[Expression]) { + pub(crate) fn permutation( + &mut self, + in_expr: &[Expression], + out_expr: &[Expression], + ) -> Result<(), RuntimeError> { let mut bits_len = 0; for i in 0..in_expr.len() { bits_len += ((i + 1) as f32).log2().ceil() as u32; @@ -764,12 +829,13 @@ impl GeneratedAcir { bits: bits.clone(), sort_by: vec![0], })); - let (_, b) = self.permutation_layer(in_expr, &bits, false); + let (_, b) = self.permutation_layer(in_expr, &bits, false)?; // Constrain the network output to out_expr for (b, o) in b.iter().zip(out_expr) { self.push_opcode(AcirOpcode::Arithmetic(b - o)); } + Ok(()) } } @@ -799,42 +865,36 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option { // Inputs for fixed based scalar multiplication // is just a scalar BlackBoxFunc::FixedBaseScalarMul => Some(1), - // TODO(#1570): Generate ACIR for recursive aggregation - // RecursiveAggregation has variable inputs and we could return `None` here, - // but as it is not fully implemented we panic for now - BlackBoxFunc::RecursiveAggregation => { - panic!("ICE: Cannot generate ACIR for recursive aggregation") - } + // Recursive aggregation has a variable number of inputs + BlackBoxFunc::RecursiveAggregation => None, } } /// This function will return the number of outputs that a blackbox function /// expects. Returning `None` if there is no expectation. -fn black_box_expected_output_size(name: BlackBoxFunc) -> u32 { +fn black_box_expected_output_size(name: BlackBoxFunc) -> Option { match name { // Bitwise opcodes will return 1 parameter which is the output // or the operation. - BlackBoxFunc::AND | BlackBoxFunc::XOR => 1, + BlackBoxFunc::AND | BlackBoxFunc::XOR => Some(1), // 32 byte hash algorithms - BlackBoxFunc::Keccak256 | BlackBoxFunc::SHA256 | BlackBoxFunc::Blake2s => 32, + BlackBoxFunc::Keccak256 | BlackBoxFunc::SHA256 | BlackBoxFunc::Blake2s => Some(32), // Hash to field returns a field element - BlackBoxFunc::HashToField128Security => 1, + BlackBoxFunc::HashToField128Security => Some(1), // Pedersen returns a point - BlackBoxFunc::Pedersen => 2, + BlackBoxFunc::Pedersen => Some(2), // Can only apply a range constraint to one // witness at a time. - BlackBoxFunc::RANGE => 0, + BlackBoxFunc::RANGE => Some(0), // Signature verification algorithms will return a boolean BlackBoxFunc::SchnorrVerify | BlackBoxFunc::EcdsaSecp256k1 - | BlackBoxFunc::EcdsaSecp256r1 => 1, + | BlackBoxFunc::EcdsaSecp256r1 => Some(1), // Output of fixed based scalar mul over the embedded curve // will be 2 field elements representing the point. - BlackBoxFunc::FixedBaseScalarMul => 2, - // TODO(#1570): Generate ACIR for recursive aggregation - BlackBoxFunc::RecursiveAggregation => { - panic!("ICE: Cannot generate ACIR for recursive aggregation") - } + BlackBoxFunc::FixedBaseScalarMul => Some(2), + // Recursive aggregation has a variable number of outputs + BlackBoxFunc::RecursiveAggregation => None, } } @@ -853,12 +913,41 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> u32 { /// #[foreign(sha256)] /// fn sha256(_input : [u8; N]) -> [u8; 32] {} /// `` -fn intrinsics_check_inputs(name: BlackBoxFunc, inputs: &[FunctionInput]) { +fn intrinsics_check_inputs(name: BlackBoxFunc, input_count: usize) { let expected_num_inputs = match black_box_func_expected_input_size(name) { Some(expected_num_inputs) => expected_num_inputs, None => return, }; - let got_num_inputs = inputs.len(); - assert_eq!(expected_num_inputs,inputs.len(),"Tried to call black box function {name} with {got_num_inputs} inputs, but this function's definition requires {expected_num_inputs} inputs"); + assert_eq!(expected_num_inputs,input_count,"Tried to call black box function {name} with {input_count} inputs, but this function's definition requires {expected_num_inputs} inputs"); +} + +/// Checks that the number of outputs being used to call the blackbox function +/// is correct according to the function definition. +/// +/// Some functions expect a variable number of outputs and in such a case, +/// this method will do nothing. An example of this is recursive aggregation. +/// In that case, this function will not check anything. +/// +/// Since we expect black box functions to be called behind a Noir shim function, +/// we trigger a compiler error if the inputs do not match. +/// +/// An example of Noir shim function is the following: +/// `` +/// #[foreign(sha256)] +/// fn verify_proof( +/// _verification_key : [Field], +/// _proof : [Field], +/// _public_inputs : [Field], +/// _key_hash : Field, +/// _input_aggregation_object : [Field; N] +/// ) -> [Field; N] {} +/// `` +fn intrinsics_check_outputs(name: BlackBoxFunc, output_count: usize) { + let expected_num_outputs = match black_box_expected_output_size(name) { + Some(expected_num_inputs) => expected_num_inputs, + None => return, + }; + + assert_eq!(expected_num_outputs,output_count,"Tried to call black box function {name} with {output_count} inputs, but this function's definition requires {expected_num_outputs} inputs"); } diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/sort.rs b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/sort.rs similarity index 76% rename from crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/sort.rs rename to crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/sort.rs index 622bf24ba65..42a6a5f1a4a 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/sort.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/acir_ir/sort.rs @@ -1,3 +1,5 @@ +use crate::errors::InternalError; + use super::generated_acir::GeneratedAcir; use acvm::acir::native_types::{Expression, Witness}; @@ -13,10 +15,10 @@ impl GeneratedAcir { in_expr: &[Expression], bits: &[Witness], generate_witness: bool, - ) -> (Vec, Vec) { + ) -> Result<(Vec, Vec), InternalError> { let n = in_expr.len(); if n == 1 { - return (Vec::new(), in_expr.to_vec()); + return Ok((Vec::new(), in_expr.to_vec())); } let n1 = n / 2; @@ -46,14 +48,17 @@ impl GeneratedAcir { in_sub2.push(&in_expr[2 * i + 1] - &intermediate); } if n % 2 == 1 { - in_sub2.push(in_expr.last().unwrap().clone()); + in_sub2.push(match in_expr.last() { + Some(in_expr) => in_expr.clone(), + None => return Err(InternalError::EmptyArray { location: self.current_location }), + }); } let mut out_expr = Vec::new(); // compute results for the sub networks let bits1 = if generate_witness { bits } else { &bits[n1 + (n - 1) / 2..] }; - let (w1, b1) = self.permutation_layer(&in_sub1, bits1, generate_witness); + let (w1, b1) = self.permutation_layer(&in_sub1, bits1, generate_witness)?; let bits2 = if generate_witness { bits } else { &bits[n1 + (n - 1) / 2 + w1.len()..] }; - let (w2, b2) = self.permutation_layer(&in_sub2, bits2, generate_witness); + let (w2, b2) = self.permutation_layer(&in_sub2, bits2, generate_witness)?; // apply the output switches for i in 0..(n - 1) / 2 { let c = if generate_witness { self.next_witness_index() } else { bits[n1 + i] }; @@ -63,11 +68,17 @@ impl GeneratedAcir { out_expr.push(&b2[i] - &intermediate); } if n % 2 == 0 { - out_expr.push(b1.last().unwrap().clone()); + out_expr.push(match b1.last() { + Some(b1) => b1.clone(), + None => return Err(InternalError::EmptyArray { location: self.current_location }), + }); } - out_expr.push(b2.last().unwrap().clone()); + out_expr.push(match b2.last() { + Some(b2) => b2.clone(), + None => return Err(InternalError::EmptyArray { location: self.current_location }), + }); conf.extend(w1); conf.extend(w2); - (conf, out_expr) + Ok((conf, out_expr)) } } diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/mod.rs b/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs similarity index 81% rename from crates/noirc_evaluator/src/ssa_refactor/acir_gen/mod.rs rename to crates/noirc_evaluator/src/ssa/acir_gen/mod.rs index b0ade9419fe..f473becd966 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/mod.rs +++ b/crates/noirc_evaluator/src/ssa/acir_gen/mod.rs @@ -1,18 +1,11 @@ //! This file holds the pass to convert from Noir's SSA IR to ACIR. +mod acir_ir; use std::collections::{HashMap, HashSet}; use std::fmt::Debug; +use std::ops::RangeInclusive; -use crate::brillig::brillig_ir::BrilligContext; -use crate::{ - brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig}, - errors::RuntimeError, -}; - -use self::acir_ir::{ - acir_variable::{AcirContext, AcirType, AcirVar}, - errors::AcirGenError, -}; +use self::acir_ir::acir_variable::{AcirContext, AcirType, AcirVar}; use super::{ ir::{ dfg::DataFlowGraph, @@ -26,17 +19,17 @@ use super::{ }, ssa_gen::Ssa, }; +use crate::brillig::brillig_ir::BrilligContext; +use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig}; +use crate::errors::{InternalError, RuntimeError}; +pub(crate) use acir_ir::generated_acir::GeneratedAcir; use acvm::{ acir::{brillig::Opcode, circuit::opcodes::BlockId, native_types::Expression}, FieldElement, }; use iter_extended::{try_vecmap, vecmap}; - -pub(crate) use acir_ir::generated_acir::GeneratedAcir; use noirc_abi::AbiDistinctness; -mod acir_ir; - /// Context struct for the acir generation pass. /// May be similar to the Evaluator struct in the current SSA IR. struct Context { @@ -62,6 +55,15 @@ struct Context { /// This set is used to ensure that a MemoryOp opcode is only pushed to the circuit /// if there is already a MemoryInit opcode. initialized_arrays: HashSet, + + /// Maps SSA values to BlockId + /// A BlockId is an ACIR structure which identifies a memory block + /// Each acir memory block corresponds to a different SSA array. + memory_blocks: HashMap, BlockId>, + + /// Number of the next BlockId, it is used to construct + /// a new BlockId + max_block_id: u32, } #[derive(Clone)] @@ -86,12 +88,13 @@ pub(crate) enum AcirValue { } impl AcirValue { - fn into_var(self) -> AcirVar { + fn into_var(self) -> Result { match self { - AcirValue::Var(var, _) => var, - AcirValue::DynamicArray(_) | AcirValue::Array(_) => { - panic!("Called AcirValue::into_var on an array") - } + AcirValue::Var(var, _) => Ok(var), + AcirValue::DynamicArray(_) | AcirValue::Array(_) => Err(InternalError::General { + message: "Called AcirValue::into_var on an array".to_string(), + location: None, + }), } } @@ -109,10 +112,9 @@ impl Ssa { self, brillig: Brillig, abi_distinctness: AbiDistinctness, - allow_log_ops: bool, ) -> Result { let context = Context::new(); - let mut generated_acir = context.convert_ssa(self, brillig, allow_log_ops)?; + let mut generated_acir = context.convert_ssa(self, brillig)?; match abi_distinctness { AbiDistinctness::Distinct => { @@ -146,19 +148,16 @@ impl Context { current_side_effects_enabled_var, acir_context, initialized_arrays: HashSet::new(), + memory_blocks: HashMap::new(), + max_block_id: 0, } } /// Converts SSA into ACIR - fn convert_ssa( - self, - ssa: Ssa, - brillig: Brillig, - allow_log_ops: bool, - ) -> Result { + fn convert_ssa(self, ssa: Ssa, brillig: Brillig) -> Result { let main_func = ssa.main(); match main_func.runtime() { - RuntimeType::Acir => self.convert_acir_main(main_func, &ssa, brillig, allow_log_ops), + RuntimeType::Acir => self.convert_acir_main(main_func, &ssa, brillig), RuntimeType::Brillig => self.convert_brillig_main(main_func, brillig), } } @@ -168,41 +167,44 @@ impl Context { main_func: &Function, ssa: &Ssa, brillig: Brillig, - allow_log_ops: bool, - ) -> Result { + ) -> Result { let dfg = &main_func.dfg; let entry_block = &dfg[main_func.entry_block()]; - - self.convert_ssa_block_params(entry_block.parameters(), dfg)?; + let input_witness = self.convert_ssa_block_params(entry_block.parameters(), dfg)?; for instruction_id in entry_block.instructions() { - self.convert_ssa_instruction(*instruction_id, dfg, ssa, &brillig, allow_log_ops)?; + self.convert_ssa_instruction(*instruction_id, dfg, ssa, &brillig)?; } - self.convert_ssa_return(entry_block.unwrap_terminator(), dfg); + self.convert_ssa_return(entry_block.unwrap_terminator(), dfg)?; - Ok(self.acir_context.finish()) + Ok(self.acir_context.finish(input_witness.collect())) } fn convert_brillig_main( mut self, main_func: &Function, brillig: Brillig, - ) -> Result { + ) -> Result { let dfg = &main_func.dfg; let inputs = try_vecmap(dfg[main_func.entry_block()].parameters(), |param_id| { let typ = dfg.type_of_value(*param_id); self.create_value_from_type(&typ, &mut |this, _| Ok(this.acir_context.add_variable())) })?; + let witness_inputs = self.acir_context.extract_witness(&inputs); let outputs: Vec = vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into()); - let code = self.gen_brillig_for(main_func, &brillig); + let code = self.gen_brillig_for(main_func, &brillig)?; - let output_values = - self.acir_context.brillig(self.current_side_effects_enabled_var, code, inputs, outputs); + let output_values = self.acir_context.brillig( + self.current_side_effects_enabled_var, + code, + inputs, + outputs, + )?; let output_vars: Vec<_> = output_values .iter() .flat_map(|value| value.clone().flatten()) @@ -210,10 +212,10 @@ impl Context { .collect(); for acir_var in output_vars { - self.acir_context.return_var(acir_var); + self.acir_context.return_var(acir_var)?; } - Ok(self.acir_context.finish()) + Ok(self.acir_context.finish(witness_inputs)) } /// Adds and binds `AcirVar`s for each numeric block parameter or block parameter array element. @@ -221,16 +223,18 @@ impl Context { &mut self, params: &[ValueId], dfg: &DataFlowGraph, - ) -> Result<(), AcirGenError> { + ) -> Result, RuntimeError> { + // The first witness (if any) is the next one + let start_witness = self.acir_context.current_witness_index().0 + 1; for param_id in params { let typ = dfg.type_of_value(*param_id); let value = self.convert_ssa_block_param(&typ)?; match &value { AcirValue::Var(_, _) => (), AcirValue::Array(values) => { - let block_id = BlockId(param_id.to_usize() as u32); + let block_id = self.block_id(param_id); let v = vecmap(values, |v| v.clone()); - self.initialize_array(block_id, values.len(), Some(&v)); + self.initialize_array(block_id, values.len(), Some(&v))?; } AcirValue::DynamicArray(_) => unreachable!( "The dynamic array type is created in Acir gen and therefore cannot be a block parameter" @@ -238,18 +242,19 @@ impl Context { } self.ssa_values.insert(*param_id, value); } - Ok(()) + let end_witness = self.acir_context.current_witness_index().0; + Ok(start_witness..=end_witness) } - fn convert_ssa_block_param(&mut self, param_type: &Type) -> Result { + fn convert_ssa_block_param(&mut self, param_type: &Type) -> Result { self.create_value_from_type(param_type, &mut |this, typ| this.add_numeric_input_var(&typ)) } fn create_value_from_type( &mut self, param_type: &Type, - make_var: &mut impl FnMut(&mut Self, NumericType) -> Result, - ) -> Result { + make_var: &mut impl FnMut(&mut Self, NumericType) -> Result, + ) -> Result { match param_type { Type::Numeric(numeric_type) => { let typ = AcirType::new(*numeric_type); @@ -270,6 +275,18 @@ impl Context { } } + /// Get the BlockId corresponding to the ValueId + /// If there is no matching BlockId, we create a new one. + fn block_id(&mut self, value: &ValueId) -> BlockId { + if let Some(block_id) = self.memory_blocks.get(value) { + return *block_id; + } + let block_id = BlockId(self.max_block_id); + self.max_block_id += 1; + self.memory_blocks.insert(*value, block_id); + block_id + } + /// Creates an `AcirVar` corresponding to a parameter witness to appears in the abi. A range /// constraint is added if the numeric type requires it. /// @@ -278,7 +295,7 @@ impl Context { fn add_numeric_input_var( &mut self, numeric_type: &NumericType, - ) -> Result { + ) -> Result { let acir_var = self.acir_context.add_variable(); if matches!(numeric_type, NumericType::Signed { .. } | NumericType::Unsigned { .. }) { self.acir_context.range_constrain_var(acir_var, numeric_type)?; @@ -293,8 +310,7 @@ impl Context { dfg: &DataFlowGraph, ssa: &Ssa, brillig: &Brillig, - allow_log_ops: bool, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { let instruction = &dfg[instruction_id]; self.acir_context.set_location(dfg.get_location(&instruction_id)); match instruction { @@ -303,7 +319,7 @@ impl Context { self.define_result_var(dfg, instruction_id, result_acir_var); } Instruction::Constrain(value_id) => { - let constrain_condition = self.convert_numeric_value(*value_id, dfg); + let constrain_condition = self.convert_numeric_value(*value_id, dfg)?; self.acir_context.assert_eq_one(constrain_condition)?; } Instruction::Cast(value_id, typ) => { @@ -322,11 +338,11 @@ impl Context { RuntimeType::Brillig => { let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg)); - let code = self.gen_brillig_for(func, brillig); + let code = self.gen_brillig_for(func, brillig)?; let outputs: Vec = vecmap(result_ids, |result_id| dfg.type_of_value(*result_id).into()); - let output_values = self.acir_context.brillig(self.current_side_effects_enabled_var, code, inputs, outputs); + let output_values = self.acir_context.brillig(self.current_side_effects_enabled_var, code, inputs, outputs)?; // Compiler sanity check assert_eq!(result_ids.len(), output_values.len(), "ICE: The number of Brillig output values should match the result ids in SSA"); @@ -338,13 +354,8 @@ impl Context { } } Value::Intrinsic(intrinsic) => { - let outputs = self.convert_ssa_intrinsic_call( - *intrinsic, - arguments, - dfg, - allow_log_ops, - result_ids, - )?; + let outputs = self + .convert_ssa_intrinsic_call(*intrinsic, arguments, dfg, result_ids)?; // Issue #1438 causes this check to fail with intrinsics that return 0 // results but the ssa form instead creates 1 unit result value. @@ -374,7 +385,7 @@ impl Context { self.define_result_var(dfg, instruction_id, result_acir_var); } Instruction::EnableSideEffects { condition } => { - let acir_var = self.convert_numeric_value(*condition, dfg); + let acir_var = self.convert_numeric_value(*condition, dfg)?; self.current_side_effects_enabled_var = acir_var; } Instruction::ArrayGet { array, index } => { @@ -397,7 +408,11 @@ impl Context { Ok(()) } - fn gen_brillig_for(&self, func: &Function, brillig: &Brillig) -> Vec { + fn gen_brillig_for( + &self, + func: &Function, + brillig: &Brillig, + ) -> Result, InternalError> { // Create the entry point artifact let mut entry_point = BrilligContext::new_entry_point_artifact( BrilligFunctionContext::parameters(func), @@ -406,13 +421,20 @@ impl Context { ); // Link the entry point with all dependencies while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() { - let artifact = &brillig - .find_by_function_label(unresolved_fn_label.clone()) - .unwrap_or_else(|| panic!("Cannot find linked fn {unresolved_fn_label}")); + let artifact = &brillig.find_by_function_label(unresolved_fn_label.clone()); + let artifact = match artifact { + Some(artifact) => artifact, + None => { + return Err(InternalError::General { + message: format!("Cannot find linked fn {unresolved_fn_label}"), + location: None, + }) + } + }; entry_point.link_with(artifact); } // Generate the final bytecode - entry_point.finish() + Ok(entry_point.finish()) } /// Handles an ArrayGet or ArraySet instruction. @@ -425,23 +447,37 @@ impl Context { index: ValueId, store_value: Option, dfg: &DataFlowGraph, - ) -> Result<(), AcirGenError> { + ) -> Result<(), RuntimeError> { let index_const = dfg.get_numeric_constant(index); match self.convert_value(array, dfg) { - AcirValue::Var(acir_var, _) => panic!("Expected an array value, found: {acir_var:?}"), + AcirValue::Var(acir_var, _) => { + return Err(RuntimeError::InternalError(InternalError::UnExpected { + expected: "an array value".to_string(), + found: format!("{acir_var:?}"), + location: self.acir_context.get_location(), + })) + } AcirValue::Array(array) => { if let Some(index_const) = index_const { let array_size = array.len(); - let index = - index_const.try_to_u64().expect("Expected array index to fit into a u64") - as usize; + let index = match index_const.try_to_u64() { + Some(index_const) => index_const as usize, + None => { + let location = self.acir_context.get_location(); + return Err(RuntimeError::TypeConversion { + from: "array index".to_string(), + into: "u64".to_string(), + location, + }); + } + }; if index >= array_size { // Ignore the error if side effects are disabled. if self.acir_context.is_constant_one(&self.current_side_effects_enabled_var) { let location = self.acir_context.get_location(); - return Err(AcirGenError::IndexOutOfBounds { + return Err(RuntimeError::IndexOutOfBounds { index, array_size, location, @@ -470,9 +506,9 @@ impl Context { } if let Some(store) = store_value { - self.array_set(instruction, array, index, store, dfg); + self.array_set(instruction, array, index, store, dfg)?; } else { - self.array_get(instruction, array, index, dfg); + self.array_get(instruction, array, index, dfg)?; } Ok(()) @@ -485,22 +521,27 @@ impl Context { array: ValueId, index: ValueId, dfg: &DataFlowGraph, - ) { + ) -> Result<(), RuntimeError> { let array = dfg.resolve(array); - let block_id = BlockId(array.to_usize() as u32); + let block_id = self.block_id(&array); if !self.initialized_arrays.contains(&block_id) { match &dfg[array] { Value::Array { array, .. } => { let values: Vec = array.iter().map(|i| self.convert_value(*i, dfg)).collect(); - self.initialize_array(block_id, array.len(), Some(&values)); + self.initialize_array(block_id, array.len(), Some(&values))?; + } + _ => { + return Err(RuntimeError::UnInitialized { + name: "array".to_string(), + location: self.acir_context.get_location(), + }) } - _ => panic!("reading uninitialized array"), } } - let index_var = self.convert_value(index, dfg).into_var(); - let read = self.acir_context.read_from_memory(block_id, &index_var); + let index_var = self.convert_value(index, dfg).into_var()?; + let read = self.acir_context.read_from_memory(block_id, &index_var)?; let typ = match dfg.type_of_value(array) { Type::Array(typ, _) => { if typ.len() != 1 { @@ -514,6 +555,7 @@ impl Context { }; let typ = AcirType::from(typ); self.define_result(dfg, instruction, AcirValue::Var(read, typ)); + Ok(()) } /// Copy the array and generates a write opcode on the new array @@ -526,14 +568,12 @@ impl Context { index: ValueId, store_value: ValueId, dfg: &DataFlowGraph, - ) { + ) -> Result<(), InternalError> { // Fetch the internal SSA ID for the array let array = dfg.resolve(array); - let array_ssa_id = array.to_usize() as u32; - // Use the SSA ID to create a block ID - // There is currently a 1-1 mapping from array SSA ID to block ID - let block_id = BlockId(array_ssa_id); + // Use the SSA ID to get or create its block ID + let block_id = self.block_id(&array); // Every array has a length in its type, so we fetch that from // the SSA IR. @@ -550,9 +590,14 @@ impl Context { Value::Array { array, .. } => { let values: Vec = array.iter().map(|i| self.convert_value(*i, dfg)).collect(); - self.initialize_array(block_id, array.len(), Some(&values)); + self.initialize_array(block_id, array.len(), Some(&values))?; + } + _ => { + return Err(InternalError::General { + message: format!("Array {array} should be initialized"), + location: self.acir_context.get_location(), + }) } - _ => panic!("Array {} should be initialized", array), } } @@ -562,38 +607,42 @@ impl Context { .instruction_results(instruction) .first() .expect("Array set does not have one result"); - let result_array_id = result_id.to_usize() as u32; - let result_block_id = BlockId(result_array_id); - - // Initialize the new array with zero values - self.initialize_array(result_block_id, len, None); + let result_block_id = self.block_id(result_id); - // Copy the values from the old array into the newly created zeroed array - for i in 0..len { + // Initialize the new array with the values from the old array + let init_values = try_vecmap(0..len, |i| { let index = AcirValue::Var( self.acir_context.add_constant(FieldElement::from(i as u128)), AcirType::NumericType(NumericType::NativeField), ); - let var = index.into_var(); - let read = self.acir_context.read_from_memory(block_id, &var); - self.acir_context.write_to_memory(result_block_id, &var, &read); - } + let var = index.into_var()?; + let read = self.acir_context.read_from_memory(block_id, &var)?; + Ok(AcirValue::Var(read, AcirType::NumericType(NumericType::NativeField))) + })?; + self.initialize_array(result_block_id, len, Some(&init_values))?; // Write the new value into the new array at the specified index - let index_var = self.convert_value(index, dfg).into_var(); - let value_var = self.convert_value(store_value, dfg).into_var(); - self.acir_context.write_to_memory(result_block_id, &index_var, &value_var); + let index_var = self.convert_value(index, dfg).into_var()?; + let value_var = self.convert_value(store_value, dfg).into_var()?; + self.acir_context.write_to_memory(result_block_id, &index_var, &value_var)?; let result_value = AcirValue::DynamicArray(AcirDynamicArray { block_id: result_block_id, len }); self.define_result(dfg, instruction, result_value); + Ok(()) } /// Initializes an array with the given values and caches the fact that we /// have initialized this array. - fn initialize_array(&mut self, array: BlockId, len: usize, values: Option<&[AcirValue]>) { - self.acir_context.initialize_array(array, len, values); + fn initialize_array( + &mut self, + array: BlockId, + len: usize, + values: Option<&[AcirValue]>, + ) -> Result<(), InternalError> { + self.acir_context.initialize_array(array, len, values)?; self.initialized_arrays.insert(array); + Ok(()) } /// Remember the result of an instruction returning a single value @@ -620,7 +669,11 @@ impl Context { } /// Converts an SSA terminator's return values into their ACIR representations - fn convert_ssa_return(&mut self, terminator: &TerminatorInstruction, dfg: &DataFlowGraph) { + fn convert_ssa_return( + &mut self, + terminator: &TerminatorInstruction, + dfg: &DataFlowGraph, + ) -> Result<(), InternalError> { let return_values = match terminator { TerminatorInstruction::Return { return_values } => return_values, _ => unreachable!("ICE: Program must have a singular return"), @@ -630,8 +683,9 @@ impl Context { // will expand the array if there is one. let return_acir_vars = self.flatten_value_list(return_values, dfg); for acir_var in return_acir_vars { - self.acir_context.return_var(acir_var); + self.acir_context.return_var(acir_var)?; } + Ok(()) } /// Gets the cached `AcirVar` that was converted from the corresponding `ValueId`. If it does @@ -675,11 +729,23 @@ impl Context { acir_value } - fn convert_numeric_value(&mut self, value_id: ValueId, dfg: &DataFlowGraph) -> AcirVar { + fn convert_numeric_value( + &mut self, + value_id: ValueId, + dfg: &DataFlowGraph, + ) -> Result { match self.convert_value(value_id, dfg) { - AcirValue::Var(acir_var, _) => acir_var, - AcirValue::Array(array) => panic!("Expected a numeric value, found: {array:?}"), - AcirValue::DynamicArray(_) => panic!("Expected a numeric value, found an array"), + AcirValue::Var(acir_var, _) => Ok(acir_var), + AcirValue::Array(array) => Err(InternalError::UnExpected { + expected: "a numeric value".to_string(), + found: format!("{array:?}"), + location: self.acir_context.get_location(), + }), + AcirValue::DynamicArray(_) => Err(InternalError::UnExpected { + expected: "a numeric value".to_string(), + found: "an array".to_string(), + location: self.acir_context.get_location(), + }), } } @@ -688,9 +754,9 @@ impl Context { &mut self, binary: &Binary, dfg: &DataFlowGraph, - ) -> Result { - let lhs = self.convert_numeric_value(binary.lhs, dfg); - let rhs = self.convert_numeric_value(binary.rhs, dfg); + ) -> Result { + let lhs = self.convert_numeric_value(binary.lhs, dfg)?; + let rhs = self.convert_numeric_value(binary.rhs, dfg)?; let binary_type = self.type_of_binary_operation(binary, dfg); match &binary_type { @@ -701,7 +767,7 @@ impl Context { // truncation technique: result % 2^bit_size to be valid. let max_integer_bit_size = FieldElement::max_num_bits() / 2; if *bit_size > max_integer_bit_size { - return Err(AcirGenError::UnsupportedIntegerSize { + return Err(RuntimeError::UnsupportedIntegerSize { num_bits: *bit_size, max_num_bits: max_integer_bit_size, location: self.acir_context.get_location(), @@ -733,13 +799,6 @@ impl Context { bit_count, self.current_side_effects_enabled_var, ), - BinaryOp::Shl => self.acir_context.shift_left_var(lhs, rhs, binary_type), - BinaryOp::Shr => self.acir_context.shift_right_var( - lhs, - rhs, - binary_type, - self.current_side_effects_enabled_var, - ), BinaryOp::Xor => self.acir_context.xor_var(lhs, rhs, binary_type), BinaryOp::And => self.acir_context.and_var(lhs, rhs, binary_type), BinaryOp::Or => self.acir_context.or_var(lhs, rhs, binary_type), @@ -809,7 +868,7 @@ impl Context { value_id: &ValueId, typ: &Type, dfg: &DataFlowGraph, - ) -> Result { + ) -> Result { let (variable, incoming_type) = match self.convert_value(*value_id, dfg) { AcirValue::Var(variable, typ) => (variable, typ), AcirValue::DynamicArray(_) | AcirValue::Array(_) => { @@ -847,8 +906,8 @@ impl Context { bit_size: u32, max_bit_size: u32, dfg: &DataFlowGraph, - ) -> Result { - let mut var = self.convert_numeric_value(value_id, dfg); + ) -> Result { + let mut var = self.convert_numeric_value(value_id, dfg)?; let truncation_target = match &dfg[value_id] { Value::Instruction { instruction, .. } => &dfg[*instruction], _ => unreachable!("ICE: Truncates are only ever applied to the result of a binary op"), @@ -873,39 +932,37 @@ impl Context { intrinsic: Intrinsic, arguments: &[ValueId], dfg: &DataFlowGraph, - allow_log_ops: bool, result_ids: &[ValueId], - ) -> Result, AcirGenError> { + ) -> Result, RuntimeError> { match intrinsic { Intrinsic::BlackBox(black_box) => { let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg)); - let vars = self.acir_context.black_box_function(black_box, inputs)?; + let output_count = result_ids.iter().fold(0usize, |sum, result_id| { + sum + dfg.try_get_array_length(*result_id).unwrap_or(1) + }); + + let vars = self.acir_context.black_box_function(black_box, inputs, output_count)?; Ok(Self::convert_vars_to_values(vars, dfg, result_ids)) } Intrinsic::ToRadix(endian) => { - let field = self.convert_value(arguments[0], dfg).into_var(); - let radix = self.convert_value(arguments[1], dfg).into_var(); - let limb_size = self.convert_value(arguments[2], dfg).into_var(); + let field = self.convert_value(arguments[0], dfg).into_var()?; + let radix = self.convert_value(arguments[1], dfg).into_var()?; + let limb_size = self.convert_value(arguments[2], dfg).into_var()?; let result_type = Self::array_element_type(dfg, result_ids[0]); self.acir_context.radix_decompose(endian, field, radix, limb_size, result_type) } Intrinsic::ToBits(endian) => { - let field = self.convert_value(arguments[0], dfg).into_var(); - let bit_size = self.convert_value(arguments[1], dfg).into_var(); + let field = self.convert_value(arguments[0], dfg).into_var()?; + let bit_size = self.convert_value(arguments[1], dfg).into_var()?; let result_type = Self::array_element_type(dfg, result_ids[0]); self.acir_context.bit_decompose(endian, field, bit_size, result_type) } - Intrinsic::Println => { - let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg)); - if allow_log_ops { - self.acir_context.print(inputs)?; - } - Ok(Vec::new()) - } + // TODO(#2115): Remove the println intrinsic as the oracle println is now used instead + Intrinsic::Println => Ok(Vec::new()), Intrinsic::Sort => { let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg)); // We flatten the inputs and retrieve the bit_size of the elements @@ -933,6 +990,14 @@ impl Context { Ok(Self::convert_vars_to_values(out_vars, dfg, result_ids)) } + Intrinsic::ArrayLen => { + let len = match self.convert_value(arguments[0], dfg) { + AcirValue::Var(_, _) => unreachable!("Non-array passed to array.len() method"), + AcirValue::Array(values) => (values.len() as u128).into(), + AcirValue::DynamicArray(array) => (array.len as u128).into(), + }; + Ok(vec![AcirValue::Var(self.acir_context.add_constant(len), AcirType::field())]) + } _ => todo!("expected a black box function"), } } @@ -1016,7 +1081,7 @@ impl Context { } /// Creates a default, meaningless value meant only to be a valid value of the given type. - fn create_default_value(&mut self, param_type: &Type) -> Result { + fn create_default_value(&mut self, param_type: &Type) -> Result { self.create_value_from_type(param_type, &mut |this, _| { Ok(this.acir_context.add_constant(FieldElement::zero())) }) @@ -1037,7 +1102,7 @@ mod tests { use crate::{ brillig::Brillig, - ssa_refactor::{ + ssa::{ ir::{function::RuntimeType, map::Id, types::Type}, ssa_builder::FunctionBuilder, }, @@ -1057,14 +1122,15 @@ mod tests { let one = builder.field_constant(FieldElement::one()); let element_type = Rc::new(vec![Type::field()]); - let array = builder.array_constant(im::Vector::unit(one), element_type); + let array_type = Type::Array(element_type, 1); + let array = builder.array_constant(im::Vector::unit(one), array_type); builder.terminate_with_return(vec![array]); let ssa = builder.finish(); let context = Context::new(); - let acir = context.convert_ssa(ssa, Brillig::default(), false).unwrap(); + let acir = context.convert_ssa(ssa, Brillig::default()).unwrap(); let expected_opcodes = vec![Opcode::Arithmetic(&Expression::one() - &Expression::from(Witness(1)))]; diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir.rs b/crates/noirc_evaluator/src/ssa/ir.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/ir.rs rename to crates/noirc_evaluator/src/ssa/ir.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/basic_block.rs b/crates/noirc_evaluator/src/ssa/ir/basic_block.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/ir/basic_block.rs rename to crates/noirc_evaluator/src/ssa/ir/basic_block.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/cfg.rs b/crates/noirc_evaluator/src/ssa/ir/cfg.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/ir/cfg.rs rename to crates/noirc_evaluator/src/ssa/ir/cfg.rs index f08b477696a..a91123438fa 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/cfg.rs +++ b/crates/noirc_evaluator/src/ssa/ir/cfg.rs @@ -128,7 +128,7 @@ impl ControlFlowGraph { #[cfg(test)] mod tests { - use crate::ssa_refactor::ir::{instruction::TerminatorInstruction, map::Id, types::Type}; + use crate::ssa::ir::{instruction::TerminatorInstruction, map::Id, types::Type}; use super::{super::function::Function, ControlFlowGraph}; diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/dfg.rs b/crates/noirc_evaluator/src/ssa/ir/dfg.rs similarity index 94% rename from crates/noirc_evaluator/src/ssa_refactor/ir/dfg.rs rename to crates/noirc_evaluator/src/ssa/ir/dfg.rs index 5c9fde280a8..1dd54499632 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/dfg.rs +++ b/crates/noirc_evaluator/src/ssa/ir/dfg.rs @@ -1,6 +1,6 @@ -use std::{borrow::Cow, collections::HashMap, rc::Rc}; +use std::{borrow::Cow, collections::HashMap}; -use crate::ssa_refactor::ir::instruction::SimplifyResult; +use crate::ssa::ir::instruction::SimplifyResult; use super::{ basic_block::{BasicBlock, BasicBlockId}, @@ -9,7 +9,7 @@ use super::{ Instruction, InstructionId, InstructionResultType, Intrinsic, TerminatorInstruction, }, map::DenseMap, - types::{CompositeType, Type}, + types::Type, value::{Value, ValueId}, }; @@ -158,7 +158,8 @@ impl DataFlowGraph { SimplifiedToMultiple(simplification) } SimplifyResult::Remove => InstructionRemoved, - SimplifyResult::None => { + result @ (SimplifyResult::SimplifiedToInstruction(_) | SimplifyResult::None) => { + let instruction = result.instruction().unwrap_or(instruction); let id = self.make_instruction(instruction, ctrl_typevars); self.blocks[block].insert_instruction(id); if let Some(location) = location { @@ -226,12 +227,9 @@ impl DataFlowGraph { } /// Create a new constant array value from the given elements - pub(crate) fn make_array( - &mut self, - array: im::Vector, - element_type: Rc, - ) -> ValueId { - self.make_value(Value::Array { array, element_type }) + pub(crate) fn make_array(&mut self, array: im::Vector, typ: Type) -> ValueId { + assert!(matches!(typ, Type::Array(..) | Type::Slice(_))); + self.make_value(Value::Array { array, typ }) } /// Gets or creates a ValueId for the given FunctionId. @@ -369,27 +367,19 @@ impl DataFlowGraph { /// Returns the Value::Array associated with this ValueId if it refers to an array constant. /// Otherwise, this returns None. - pub(crate) fn get_array_constant( - &self, - value: ValueId, - ) -> Option<(im::Vector, Rc)> { + pub(crate) fn get_array_constant(&self, value: ValueId) -> Option<(im::Vector, Type)> { match &self.values[self.resolve(value)] { - // Vectors are shared, so cloning them is cheap - Value::Array { array, element_type } => Some((array.clone(), element_type.clone())), + // Arrays are shared, so cloning them is cheap + Value::Array { array, typ } => Some((array.clone(), typ.clone())), _ => None, } } - /// Returns the Type::Array associated with this ValueId if it refers to an array parameter. - /// Otherwise, this returns None. - pub(crate) fn get_array_parameter_type( - &self, - value: ValueId, - ) -> Option<(Rc, usize)> { - match &self.values[self.resolve(value)] { - Value::Param { typ: Type::Array(element_type, size), .. } => { - Some((element_type.clone(), *size)) - } + /// If this value is an array, return the length of the array as indicated by its type. + /// Otherwise, return None. + pub(crate) fn try_get_array_length(&self, value: ValueId) -> Option { + match self.type_of_value(value) { + Type::Array(_, length) => Some(length), _ => None, } } @@ -513,7 +503,7 @@ impl<'dfg> InsertInstructionResult<'dfg> { #[cfg(test)] mod tests { use super::DataFlowGraph; - use crate::ssa_refactor::ir::instruction::Instruction; + use crate::ssa::ir::instruction::Instruction; #[test] fn make_instruction() { diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/dom.rs b/crates/noirc_evaluator/src/ssa/ir/dom.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/ir/dom.rs rename to crates/noirc_evaluator/src/ssa/ir/dom.rs index 4763ffffbd1..b7b1728d035 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/dom.rs +++ b/crates/noirc_evaluator/src/ssa/ir/dom.rs @@ -245,7 +245,7 @@ impl DominatorTree { mod tests { use std::cmp::Ordering; - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ basic_block::BasicBlockId, dom::DominatorTree, diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/function.rs b/crates/noirc_evaluator/src/ssa/ir/function.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/ir/function.rs rename to crates/noirc_evaluator/src/ssa/ir/function.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/function_inserter.rs b/crates/noirc_evaluator/src/ssa/ir/function_inserter.rs similarity index 95% rename from crates/noirc_evaluator/src/ssa_refactor/ir/function_inserter.rs rename to crates/noirc_evaluator/src/ssa/ir/function_inserter.rs index 22a1399ae79..15c755f40c2 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/function_inserter.rs +++ b/crates/noirc_evaluator/src/ssa/ir/function_inserter.rs @@ -33,11 +33,11 @@ impl<'f> FunctionInserter<'f> { match self.values.get(&value) { Some(value) => *value, None => match &self.function.dfg[value] { - super::value::Value::Array { array, element_type } => { + super::value::Value::Array { array, typ } => { let array = array.clone(); - let element_type = element_type.clone(); + let typ = typ.clone(); let new_array = array.iter().map(|id| self.resolve(*id)).collect(); - let new_id = self.function.dfg.make_array(new_array, element_type); + let new_id = self.function.dfg.make_array(new_array, typ); self.values.insert(value, new_id); new_id } @@ -124,7 +124,6 @@ impl<'f> FunctionInserter<'f> { let old_parameters = self.function.dfg.block_parameters(block); for (param, new_param) in old_parameters.iter().zip(new_values) { - // Don't overwrite any existing entries to avoid overwriting the induction variable self.values.entry(*param).or_insert(*new_param); } } diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs b/crates/noirc_evaluator/src/ssa/ir/instruction.rs similarity index 80% rename from crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs rename to crates/noirc_evaluator/src/ssa/ir/instruction.rs index 416c53ba6b4..680715fb0ec 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs +++ b/crates/noirc_evaluator/src/ssa/ir/instruction.rs @@ -1,19 +1,19 @@ -use std::rc::Rc; - use acvm::{acir::BlackBoxFunc, FieldElement}; use iter_extended::vecmap; use num_bigint::BigUint; -use crate::ssa_refactor::ir::types::NumericType; - use super::{ basic_block::BasicBlockId, dfg::DataFlowGraph, map::Id, - types::Type, + types::{NumericType, Type}, value::{Value, ValueId}, }; +mod call; + +use call::simplify_call; + /// Reference to an instruction /// /// Note that InstructionIds are not unique. That is, two InstructionIds @@ -385,160 +385,6 @@ fn simplify_cast(value: ValueId, dst_typ: &Type, dfg: &mut DataFlowGraph) -> Sim } } -/// Try to simplify this call instruction. If the instruction can be simplified to a known value, -/// that value is returned. Otherwise None is returned. -fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph) -> SimplifyResult { - use SimplifyResult::*; - let intrinsic = match &dfg[func] { - Value::Intrinsic(intrinsic) => *intrinsic, - _ => return None, - }; - - let constant_args: Option> = - arguments.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect(); - - match intrinsic { - Intrinsic::ToBits(endian) => { - if let Some(constant_args) = constant_args { - let field = constant_args[0]; - let limb_count = constant_args[1].to_u128() as u32; - SimplifiedTo(constant_to_radix(endian, field, 2, limb_count, dfg)) - } else { - None - } - } - Intrinsic::ToRadix(endian) => { - if let Some(constant_args) = constant_args { - let field = constant_args[0]; - let radix = constant_args[1].to_u128() as u32; - let limb_count = constant_args[2].to_u128() as u32; - SimplifiedTo(constant_to_radix(endian, field, radix, limb_count, dfg)) - } else { - None - } - } - Intrinsic::ArrayLen => { - let slice = dfg.get_array_constant(arguments[0]); - if let Some((slice, _)) = slice { - let slice_len = - dfg.make_constant(FieldElement::from(slice.len() as u128), Type::field()); - SimplifiedTo(slice_len) - } else if let Some((_, slice_len)) = dfg.get_array_parameter_type(arguments[0]) { - let slice_len = dfg.make_constant( - FieldElement::from(slice_len as u128), - Type::Numeric(NumericType::NativeField), - ); - SimplifiedTo(slice_len) - } else { - None - } - } - Intrinsic::SlicePushBack => { - let slice = dfg.get_array_constant(arguments[0]); - if let (Some((mut slice, element_type)), elem) = (slice, arguments[1]) { - slice.push_back(elem); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedTo(new_slice) - } else { - None - } - } - Intrinsic::SlicePushFront => { - let slice = dfg.get_array_constant(arguments[0]); - if let (Some((mut slice, element_type)), elem) = (slice, arguments[1]) { - slice.push_front(elem); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedTo(new_slice) - } else { - None - } - } - Intrinsic::SlicePopBack => { - let slice = dfg.get_array_constant(arguments[0]); - if let Some((mut slice, element_type)) = slice { - let elem = - slice.pop_back().expect("There are no elements in this slice to be removed"); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedToMultiple(vec![new_slice, elem]) - } else { - None - } - } - Intrinsic::SlicePopFront => { - let slice = dfg.get_array_constant(arguments[0]); - if let Some((mut slice, element_type)) = slice { - let elem = - slice.pop_front().expect("There are no elements in this slice to be removed"); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedToMultiple(vec![elem, new_slice]) - } else { - None - } - } - Intrinsic::SliceInsert => { - let slice = dfg.get_array_constant(arguments[0]); - let index = dfg.get_numeric_constant(arguments[1]); - if let (Some((mut slice, element_type)), Some(index), value) = - (slice, index, arguments[2]) - { - slice.insert(index.to_u128() as usize, value); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedTo(new_slice) - } else { - None - } - } - Intrinsic::SliceRemove => { - let slice = dfg.get_array_constant(arguments[0]); - let index = dfg.get_numeric_constant(arguments[1]); - if let (Some((mut slice, element_type)), Some(index)) = (slice, index) { - let removed_elem = slice.remove(index.to_u128() as usize); - let new_slice = dfg.make_array(slice, element_type); - SimplifiedToMultiple(vec![new_slice, removed_elem]) - } else { - None - } - } - Intrinsic::BlackBox(_) | Intrinsic::Println | Intrinsic::Sort => None, - } -} - -/// Returns a Value::Array of constants corresponding to the limbs of the radix decomposition. -fn constant_to_radix( - endian: Endian, - field: FieldElement, - radix: u32, - limb_count: u32, - dfg: &mut DataFlowGraph, -) -> ValueId { - let bit_size = u32::BITS - (radix - 1).leading_zeros(); - let radix_big = BigUint::from(radix); - assert_eq!(BigUint::from(2u128).pow(bit_size), radix_big, "ICE: Radix must be a power of 2"); - let big_integer = BigUint::from_bytes_be(&field.to_be_bytes()); - - // Decompose the integer into its radix digits in little endian form. - let decomposed_integer = big_integer.to_radix_le(radix); - let mut limbs = vecmap(0..limb_count, |i| match decomposed_integer.get(i as usize) { - Some(digit) => FieldElement::from_be_bytes_reduce(&[*digit]), - None => FieldElement::zero(), - }); - if endian == Endian::Big { - limbs.reverse(); - } - - // For legacy reasons (see #617) the to_radix interface supports 256 bits even though - // FieldElement::max_num_bits() is only 254 bits. Any limbs beyond the specified count - // become zero padding. - let max_decomposable_bits: u32 = 256; - let limb_count_with_padding = max_decomposable_bits / bit_size; - while limbs.len() < limb_count_with_padding as usize { - limbs.push(FieldElement::zero()); - } - let result_constants = - limbs.into_iter().map(|limb| dfg.make_constant(limb, Type::unsigned(bit_size))).collect(); - dfg.make_array(result_constants, Rc::new(vec![Type::unsigned(bit_size)])) -} - /// The possible return values for Instruction::return_types pub(crate) enum InstructionResultType { /// The result type of this instruction matches that of this operand @@ -737,6 +583,14 @@ impl Binary { let zero = dfg.make_constant(FieldElement::zero(), operand_type); return SimplifyResult::SimplifiedTo(zero); } + if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) { + return SimplifyResult::SimplifiedTo(self.lhs); + } + if operand_type == Type::bool() { + // Boolean AND is equivalent to multiplication, which is a cheaper operation. + let instruction = Instruction::binary(BinaryOp::Mul, self.lhs, self.rhs); + return SimplifyResult::SimplifiedToInstruction(instruction); + } } BinaryOp::Or => { if lhs_is_zero { @@ -745,22 +599,21 @@ impl Binary { if rhs_is_zero { return SimplifyResult::SimplifiedTo(self.lhs); } - } - BinaryOp::Xor => { if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) { - let zero = dfg.make_constant(FieldElement::zero(), Type::bool()); - return SimplifyResult::SimplifiedTo(zero); - } - } - BinaryOp::Shl => { - if rhs_is_zero { return SimplifyResult::SimplifiedTo(self.lhs); } } - BinaryOp::Shr => { + BinaryOp::Xor => { + if lhs_is_zero { + return SimplifyResult::SimplifiedTo(self.rhs); + } if rhs_is_zero { return SimplifyResult::SimplifiedTo(self.lhs); } + if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) { + let zero = dfg.make_constant(FieldElement::zero(), Type::bool()); + return SimplifyResult::SimplifiedTo(zero); + } } } SimplifyResult::None @@ -817,8 +670,6 @@ impl BinaryOp { BinaryOp::And => None, BinaryOp::Or => None, BinaryOp::Xor => None, - BinaryOp::Shl => None, - BinaryOp::Shr => None, } } @@ -832,8 +683,6 @@ impl BinaryOp { BinaryOp::And => |x, y| Some(x & y), BinaryOp::Or => |x, y| Some(x | y), BinaryOp::Xor => |x, y| Some(x ^ y), - BinaryOp::Shl => |x, y| x.checked_shl(y.try_into().ok()?), - BinaryOp::Shr => |x, y| Some(x >> y), BinaryOp::Eq => |x, y| Some((x == y) as u128), BinaryOp::Lt => |x, y| Some((x < y) as u128), } @@ -874,10 +723,6 @@ pub(crate) enum BinaryOp { Or, /// Bitwise xor (^) Xor, - /// Shift lhs left by rhs bits (<<) - Shl, - /// Shift lhs right by rhs bits (>>) - Shr, } impl std::fmt::Display for BinaryOp { @@ -893,8 +738,6 @@ impl std::fmt::Display for BinaryOp { BinaryOp::And => write!(f, "and"), BinaryOp::Or => write!(f, "or"), BinaryOp::Xor => write!(f, "xor"), - BinaryOp::Shl => write!(f, "shl"), - BinaryOp::Shr => write!(f, "shr"), } } } @@ -910,9 +753,21 @@ pub(crate) enum SimplifyResult { /// a function such as a tuple SimplifiedToMultiple(Vec), + /// Replace this function with an simpler but equivalent function. + SimplifiedToInstruction(Instruction), + /// Remove the instruction, it is unnecessary Remove, /// Instruction could not be simplified None, } + +impl SimplifyResult { + pub(crate) fn instruction(self) -> Option { + match self { + SimplifyResult::SimplifiedToInstruction(instruction) => Some(instruction), + _ => None, + } + } +} diff --git a/crates/noirc_evaluator/src/ssa/ir/instruction/call.rs b/crates/noirc_evaluator/src/ssa/ir/instruction/call.rs new file mode 100644 index 00000000000..d5925080870 --- /dev/null +++ b/crates/noirc_evaluator/src/ssa/ir/instruction/call.rs @@ -0,0 +1,368 @@ +use std::{collections::VecDeque, rc::Rc}; + +use acvm::{acir::BlackBoxFunc, BlackBoxResolutionError, FieldElement}; +use iter_extended::vecmap; +use num_bigint::BigUint; + +use crate::ssa::ir::{ + dfg::DataFlowGraph, + instruction::Intrinsic, + map::Id, + types::Type, + value::{Value, ValueId}, +}; + +use super::{Endian, SimplifyResult}; + +/// Try to simplify this call instruction. If the instruction can be simplified to a known value, +/// that value is returned. Otherwise None is returned. +pub(super) fn simplify_call( + func: ValueId, + arguments: &[ValueId], + dfg: &mut DataFlowGraph, +) -> SimplifyResult { + let intrinsic = match &dfg[func] { + Value::Intrinsic(intrinsic) => *intrinsic, + _ => return SimplifyResult::None, + }; + + let constant_args: Option> = + arguments.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect(); + + match intrinsic { + Intrinsic::ToBits(endian) => { + if let Some(constant_args) = constant_args { + let field = constant_args[0]; + let limb_count = constant_args[1].to_u128() as u32; + SimplifyResult::SimplifiedTo(constant_to_radix(endian, field, 2, limb_count, dfg)) + } else { + SimplifyResult::None + } + } + Intrinsic::ToRadix(endian) => { + if let Some(constant_args) = constant_args { + let field = constant_args[0]; + let radix = constant_args[1].to_u128() as u32; + let limb_count = constant_args[2].to_u128() as u32; + SimplifyResult::SimplifiedTo(constant_to_radix( + endian, field, radix, limb_count, dfg, + )) + } else { + SimplifyResult::None + } + } + Intrinsic::ArrayLen => { + let slice = dfg.get_array_constant(arguments[0]); + if let Some((slice, typ)) = slice { + let length = FieldElement::from((slice.len() / typ.element_size()) as u128); + SimplifyResult::SimplifiedTo(dfg.make_constant(length, Type::field())) + } else if let Some(length) = dfg.try_get_array_length(arguments[0]) { + let length = FieldElement::from(length as u128); + SimplifyResult::SimplifiedTo(dfg.make_constant(length, Type::field())) + } else { + SimplifyResult::None + } + } + Intrinsic::SlicePushBack => { + let slice = dfg.get_array_constant(arguments[0]); + if let Some((mut slice, element_type)) = slice { + for elem in &arguments[1..] { + slice.push_back(*elem); + } + let new_slice = dfg.make_array(slice, element_type); + SimplifyResult::SimplifiedTo(new_slice) + } else { + SimplifyResult::None + } + } + Intrinsic::SlicePushFront => { + let slice = dfg.get_array_constant(arguments[0]); + if let Some((mut slice, element_type)) = slice { + for elem in arguments[1..].iter().rev() { + slice.push_front(*elem); + } + let new_slice = dfg.make_array(slice, element_type); + SimplifyResult::SimplifiedTo(new_slice) + } else { + SimplifyResult::None + } + } + Intrinsic::SlicePopBack => { + let slice = dfg.get_array_constant(arguments[0]); + if let Some((mut slice, typ)) = slice { + let element_count = typ.element_size(); + let mut results = VecDeque::with_capacity(element_count + 1); + + // We must pop multiple elements in the case of a slice of tuples + for _ in 0..element_count { + let elem = slice + .pop_back() + .expect("There are no elements in this slice to be removed"); + results.push_front(elem); + } + + let new_slice = dfg.make_array(slice, typ); + results.push_front(new_slice); + + SimplifyResult::SimplifiedToMultiple(results.into()) + } else { + SimplifyResult::None + } + } + Intrinsic::SlicePopFront => { + let slice = dfg.get_array_constant(arguments[0]); + if let Some((mut slice, typ)) = slice { + let element_count = typ.element_size(); + + // We must pop multiple elements in the case of a slice of tuples + let mut results = vecmap(0..element_count, |_| { + slice.pop_front().expect("There are no elements in this slice to be removed") + }); + + let new_slice = dfg.make_array(slice, typ); + + // The slice is the last item returned for pop_front + results.push(new_slice); + SimplifyResult::SimplifiedToMultiple(results) + } else { + SimplifyResult::None + } + } + Intrinsic::SliceInsert => { + let slice = dfg.get_array_constant(arguments[0]); + let index = dfg.get_numeric_constant(arguments[1]); + if let (Some((mut slice, typ)), Some(index)) = (slice, index) { + let elements = &arguments[2..]; + let mut index = index.to_u128() as usize * elements.len(); + + for elem in &arguments[2..] { + slice.insert(index, *elem); + index += 1; + } + + let new_slice = dfg.make_array(slice, typ); + SimplifyResult::SimplifiedTo(new_slice) + } else { + SimplifyResult::None + } + } + Intrinsic::SliceRemove => { + let slice = dfg.get_array_constant(arguments[0]); + let index = dfg.get_numeric_constant(arguments[1]); + if let (Some((mut slice, typ)), Some(index)) = (slice, index) { + let element_count = typ.element_size(); + let mut results = Vec::with_capacity(element_count + 1); + let index = index.to_u128() as usize * element_count; + + for _ in 0..element_count { + results.push(slice.remove(index)); + } + + let new_slice = dfg.make_array(slice, typ); + results.insert(0, new_slice); + SimplifyResult::SimplifiedToMultiple(results) + } else { + SimplifyResult::None + } + } + Intrinsic::BlackBox(bb_func) => simplify_black_box_func(bb_func, arguments, dfg), + Intrinsic::Println | Intrinsic::Sort => SimplifyResult::None, + } +} + +/// Try to simplify this black box call. If the call can be simplified to a known value, +/// that value is returned. Otherwise [`SimplifyResult::None`] is returned. +fn simplify_black_box_func( + bb_func: BlackBoxFunc, + arguments: &[ValueId], + dfg: &mut DataFlowGraph, +) -> SimplifyResult { + match bb_func { + BlackBoxFunc::SHA256 => simplify_hash(dfg, arguments, acvm::blackbox_solver::sha256), + BlackBoxFunc::Blake2s => simplify_hash(dfg, arguments, acvm::blackbox_solver::blake2s), + BlackBoxFunc::Keccak256 => { + match (dfg.get_array_constant(arguments[0]), dfg.get_numeric_constant(arguments[1])) { + (Some((input, _)), Some(num_bytes)) if array_is_constant(dfg, &input) => { + let input_bytes: Vec = to_u8_vec(dfg, input); + + let num_bytes = num_bytes.to_u128() as usize; + let truncated_input_bytes = &input_bytes[0..num_bytes]; + let hash = acvm::blackbox_solver::keccak256(truncated_input_bytes) + .expect("Rust solvable black box function should not fail"); + + let hash_values = + vecmap(hash, |byte| FieldElement::from_be_bytes_reduce(&[byte])); + + let result_array = make_constant_array(dfg, hash_values, Type::unsigned(8)); + SimplifyResult::SimplifiedTo(result_array) + } + _ => SimplifyResult::None, + } + } + BlackBoxFunc::HashToField128Security => match dfg.get_array_constant(arguments[0]) { + Some((input, _)) if array_is_constant(dfg, &input) => { + let input_bytes: Vec = to_u8_vec(dfg, input); + + let field = acvm::blackbox_solver::hash_to_field_128_security(&input_bytes) + .expect("Rust solvable black box function should not fail"); + + let field_constant = dfg.make_constant(field, Type::field()); + SimplifyResult::SimplifiedTo(field_constant) + } + _ => SimplifyResult::None, + }, + + BlackBoxFunc::EcdsaSecp256k1 => { + simplify_signature(dfg, arguments, acvm::blackbox_solver::ecdsa_secp256k1_verify) + } + BlackBoxFunc::EcdsaSecp256r1 => { + simplify_signature(dfg, arguments, acvm::blackbox_solver::ecdsa_secp256r1_verify) + } + + BlackBoxFunc::FixedBaseScalarMul | BlackBoxFunc::SchnorrVerify | BlackBoxFunc::Pedersen => { + // Currently unsolvable here as we rely on an implementation in the backend. + SimplifyResult::None + } + + BlackBoxFunc::RecursiveAggregation => SimplifyResult::None, + + BlackBoxFunc::AND => { + unreachable!("ICE: `BlackBoxFunc::AND` calls should be transformed into a `BinaryOp`") + } + BlackBoxFunc::XOR => { + unreachable!("ICE: `BlackBoxFunc::XOR` calls should be transformed into a `BinaryOp`") + } + BlackBoxFunc::RANGE => { + unreachable!( + "ICE: `BlackBoxFunc::RANGE` calls should be transformed into a `Instruction::Cast`" + ) + } + } +} + +fn make_constant_array(dfg: &mut DataFlowGraph, results: Vec, typ: Type) -> ValueId { + let result_constants = vecmap(results, |element| dfg.make_constant(element, typ.clone())); + + let typ = Type::Array(Rc::new(vec![typ]), result_constants.len()); + dfg.make_array(result_constants.into(), typ) +} + +/// Returns a Value::Array of constants corresponding to the limbs of the radix decomposition. +fn constant_to_radix( + endian: Endian, + field: FieldElement, + radix: u32, + limb_count: u32, + dfg: &mut DataFlowGraph, +) -> ValueId { + let bit_size = u32::BITS - (radix - 1).leading_zeros(); + let radix_big = BigUint::from(radix); + assert_eq!(BigUint::from(2u128).pow(bit_size), radix_big, "ICE: Radix must be a power of 2"); + let big_integer = BigUint::from_bytes_be(&field.to_be_bytes()); + + // Decompose the integer into its radix digits in little endian form. + let decomposed_integer = big_integer.to_radix_le(radix); + let mut limbs = vecmap(0..limb_count, |i| match decomposed_integer.get(i as usize) { + Some(digit) => FieldElement::from_be_bytes_reduce(&[*digit]), + None => FieldElement::zero(), + }); + if endian == Endian::Big { + limbs.reverse(); + } + + // For legacy reasons (see #617) the to_radix interface supports 256 bits even though + // FieldElement::max_num_bits() is only 254 bits. Any limbs beyond the specified count + // become zero padding. + let max_decomposable_bits: u32 = 256; + let limb_count_with_padding = max_decomposable_bits / bit_size; + while limbs.len() < limb_count_with_padding as usize { + limbs.push(FieldElement::zero()); + } + + make_constant_array(dfg, limbs, Type::unsigned(bit_size)) +} + +fn to_u8_vec(dfg: &DataFlowGraph, values: im::Vector>) -> Vec { + values + .iter() + .map(|id| { + let field = dfg + .get_numeric_constant(*id) + .expect("value id from array should point at constant"); + *field.to_be_bytes().last().unwrap() + }) + .collect() +} + +fn array_is_constant(dfg: &DataFlowGraph, values: &im::Vector>) -> bool { + values.iter().all(|value| dfg.get_numeric_constant(*value).is_some()) +} + +fn simplify_hash( + dfg: &mut DataFlowGraph, + arguments: &[ValueId], + hash_function: fn(&[u8]) -> Result<[u8; 32], BlackBoxResolutionError>, +) -> SimplifyResult { + match dfg.get_array_constant(arguments[0]) { + Some((input, _)) if array_is_constant(dfg, &input) => { + let input_bytes: Vec = to_u8_vec(dfg, input); + + let hash = hash_function(&input_bytes) + .expect("Rust solvable black box function should not fail"); + + let hash_values = vecmap(hash, |byte| FieldElement::from_be_bytes_reduce(&[byte])); + + let result_array = make_constant_array(dfg, hash_values, Type::unsigned(8)); + SimplifyResult::SimplifiedTo(result_array) + } + _ => SimplifyResult::None, + } +} + +type ECDSASignatureVerifier = fn( + hashed_msg: &[u8], + public_key_x: &[u8; 32], + public_key_y: &[u8; 32], + signature: &[u8; 64], +) -> Result; +fn simplify_signature( + dfg: &mut DataFlowGraph, + arguments: &[ValueId], + signature_verifier: ECDSASignatureVerifier, +) -> SimplifyResult { + match ( + dfg.get_array_constant(arguments[0]), + dfg.get_array_constant(arguments[1]), + dfg.get_array_constant(arguments[2]), + dfg.get_array_constant(arguments[3]), + ) { + ( + Some((public_key_x, _)), + Some((public_key_y, _)), + Some((signature, _)), + Some((hashed_message, _)), + ) if array_is_constant(dfg, &public_key_x) + && array_is_constant(dfg, &public_key_y) + && array_is_constant(dfg, &signature) + && array_is_constant(dfg, &hashed_message) => + { + let public_key_x: [u8; 32] = to_u8_vec(dfg, public_key_x) + .try_into() + .expect("ECDSA public key fields are 32 bytes"); + let public_key_y: [u8; 32] = to_u8_vec(dfg, public_key_y) + .try_into() + .expect("ECDSA public key fields are 32 bytes"); + let signature: [u8; 64] = + to_u8_vec(dfg, signature).try_into().expect("ECDSA signatures are 64 bytes"); + let hashed_message: Vec = to_u8_vec(dfg, hashed_message); + + let valid_signature = + signature_verifier(&hashed_message, &public_key_x, &public_key_y, &signature) + .expect("Rust solvable black box function should not fail"); + + let valid_signature = dfg.make_constant(valid_signature.into(), Type::bool()); + SimplifyResult::SimplifiedTo(valid_signature) + } + _ => SimplifyResult::None, + } +} diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/map.rs b/crates/noirc_evaluator/src/ssa/ir/map.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/ir/map.rs rename to crates/noirc_evaluator/src/ssa/ir/map.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/post_order.rs b/crates/noirc_evaluator/src/ssa/ir/post_order.rs similarity index 97% rename from crates/noirc_evaluator/src/ssa_refactor/ir/post_order.rs rename to crates/noirc_evaluator/src/ssa/ir/post_order.rs index 2f7b5edebe6..202f5cff716 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/post_order.rs +++ b/crates/noirc_evaluator/src/ssa/ir/post_order.rs @@ -5,7 +5,7 @@ use std::collections::HashSet; -use crate::ssa_refactor::ir::{basic_block::BasicBlockId, function::Function}; +use crate::ssa::ir::{basic_block::BasicBlockId, function::Function}; /// Depth-first traversal stack state marker for computing the cfg post-order. enum Visit { @@ -67,7 +67,7 @@ impl PostOrder { #[cfg(test)] mod tests { - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ function::{Function, RuntimeType}, map::Id, diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/printer.rs b/crates/noirc_evaluator/src/ssa/ir/printer.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/ir/printer.rs rename to crates/noirc_evaluator/src/ssa/ir/printer.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/types.rs b/crates/noirc_evaluator/src/ssa/ir/types.rs similarity index 85% rename from crates/noirc_evaluator/src/ssa_refactor/ir/types.rs rename to crates/noirc_evaluator/src/ssa/ir/types.rs index 7e37a72ff83..38dd6125121 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/types.rs +++ b/crates/noirc_evaluator/src/ssa/ir/types.rs @@ -61,6 +61,17 @@ impl Type { pub(crate) fn field() -> Type { Type::Numeric(NumericType::NativeField) } + + /// Returns the size of the element type for this array/slice. + /// The size of a type is defined as representing how many Fields are needed + /// to represent the type. This is 1 for every primitive type, and is the number of fields + /// for any flattened tuple type. + pub(crate) fn element_size(&self) -> usize { + match self { + Type::Array(elements, _) | Type::Slice(elements) => elements.len(), + other => panic!("element_size: Expected array or slice, found {other}"), + } + } } /// Composite Types are essentially flattened struct or tuple types. diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/value.rs b/crates/noirc_evaluator/src/ssa/ir/value.rs similarity index 88% rename from crates/noirc_evaluator/src/ssa_refactor/ir/value.rs rename to crates/noirc_evaluator/src/ssa/ir/value.rs index 03475f5f514..54831eb4a07 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ir/value.rs +++ b/crates/noirc_evaluator/src/ssa/ir/value.rs @@ -1,14 +1,12 @@ -use std::rc::Rc; - use acvm::FieldElement; -use crate::ssa_refactor::ir::basic_block::BasicBlockId; +use crate::ssa::ir::basic_block::BasicBlockId; use super::{ function::FunctionId, instruction::{InstructionId, Intrinsic}, map::Id, - types::{CompositeType, Type}, + types::Type, }; pub(crate) type ValueId = Id; @@ -38,7 +36,7 @@ pub(crate) enum Value { NumericConstant { constant: FieldElement, typ: Type }, /// Represents a constant array value - Array { array: im::Vector, element_type: Rc }, + Array { array: im::Vector, typ: Type }, /// This Value refers to a function in the IR. /// Functions always have the type Type::Function. @@ -64,9 +62,7 @@ impl Value { Value::Instruction { typ, .. } => typ.clone(), Value::Param { typ, .. } => typ.clone(), Value::NumericConstant { typ, .. } => typ.clone(), - Value::Array { element_type, array } => { - Type::Array(element_type.clone(), array.len() / element_type.len()) - } + Value::Array { typ, .. } => typ.clone(), Value::Function { .. } => Type::Function, Value::Intrinsic { .. } => Type::Function, Value::ForeignFunction { .. } => Type::Function, diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/constant_folding.rs b/crates/noirc_evaluator/src/ssa/opt/constant_folding.rs similarity index 96% rename from crates/noirc_evaluator/src/ssa_refactor/opt/constant_folding.rs rename to crates/noirc_evaluator/src/ssa/opt/constant_folding.rs index 3c40e2a15c5..ea46ddf1d4f 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/constant_folding.rs +++ b/crates/noirc_evaluator/src/ssa/opt/constant_folding.rs @@ -2,7 +2,7 @@ use std::collections::HashSet; use iter_extended::vecmap; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, dfg::InsertInstructionResult, function::Function, instruction::InstructionId, @@ -92,7 +92,9 @@ impl Context { #[cfg(test)] mod test { - use crate::ssa_refactor::{ + use std::rc::Rc; + + use crate::ssa::{ ir::{ function::RuntimeType, instruction::{BinaryOp, TerminatorInstruction}, @@ -176,8 +178,9 @@ mod test { let v0 = builder.add_parameter(Type::field()); let one = builder.field_constant(1u128); let v1 = builder.insert_binary(v0, BinaryOp::Add, one); - let arr = - builder.current_function.dfg.make_array(vec![v1].into(), vec![Type::field()].into()); + + let array_type = Type::Array(Rc::new(vec![Type::field()]), 1); + let arr = builder.current_function.dfg.make_array(vec![v1].into(), array_type); builder.terminate_with_return(vec![arr]); let ssa = builder.finish().fold_constants(); diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/defunctionalize.rs b/crates/noirc_evaluator/src/ssa/opt/defunctionalize.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/opt/defunctionalize.rs rename to crates/noirc_evaluator/src/ssa/opt/defunctionalize.rs index fc3bc5d9aa6..10561bf731f 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/defunctionalize.rs +++ b/crates/noirc_evaluator/src/ssa/opt/defunctionalize.rs @@ -9,7 +9,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use acvm::FieldElement; use iter_extended::vecmap; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, function::{Function, FunctionId, RuntimeType, Signature}, diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/die.rs b/crates/noirc_evaluator/src/ssa/opt/die.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/opt/die.rs rename to crates/noirc_evaluator/src/ssa/opt/die.rs index ef73938cc37..935568af2db 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/die.rs +++ b/crates/noirc_evaluator/src/ssa/opt/die.rs @@ -2,7 +2,7 @@ //! which the results are unused. use std::collections::HashSet; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::{BasicBlock, BasicBlockId}, dfg::DataFlowGraph, @@ -133,7 +133,7 @@ impl Context { #[cfg(test)] mod test { - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{function::RuntimeType, instruction::BinaryOp, map::Id, types::Type}, ssa_builder::FunctionBuilder, }; diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg.rs b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs similarity index 98% rename from crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg.rs rename to crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs index ac62071d6ee..1bcdf433d79 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg.rs +++ b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg.rs @@ -131,16 +131,13 @@ //! v11 = mul v4, Field 12 //! v12 = add v10, v11 //! store v12 at v5 (new store) -use std::{ - collections::{BTreeMap, HashMap, HashSet}, - rc::Rc, -}; +use std::collections::{BTreeMap, HashMap, HashSet}; use acvm::FieldElement; use iter_extended::vecmap; use noirc_errors::Location; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, cfg::ControlFlowGraph, @@ -148,7 +145,7 @@ use crate::ssa_refactor::{ function::Function, function_inserter::FunctionInserter, instruction::{BinaryOp, Instruction, InstructionId, TerminatorInstruction}, - types::{CompositeType, Type}, + types::Type, value::ValueId, }, ssa_gen::Ssa, @@ -216,7 +213,7 @@ fn flatten_function_cfg(function: &mut Function) { // TODO This loops forever, if the predecessors are not then processed // TODO Because it will visit the same block again, pop it out of the queue // TODO then back into the queue again. - if let crate::ssa_refactor::ir::function::RuntimeType::Brillig = function.runtime() { + if let crate::ssa::ir::function::RuntimeType::Brillig = function.runtime() { return; } let cfg = ControlFlowGraph::with_function(function); @@ -277,7 +274,10 @@ impl<'f> Context<'f> { // end, in addition to resetting the value of old_condition since it is set to // known to be true/false within the then/else branch respectively. self.insert_current_side_effects_enabled(); - self.inserter.map_value(old_condition, old_condition); + + // We must map back to `then_condition` here. Mapping `old_condition` to itself would + // lose any previous mappings. + self.inserter.map_value(old_condition, then_condition); // While there is a condition on the stack we don't compile outside the condition // until it is popped. This ensures we inline the full then and else branches @@ -393,14 +393,9 @@ impl<'f> Context<'f> { Type::Numeric(_) => { self.merge_numeric_values(then_condition, else_condition, then_value, else_value) } - Type::Array(element_types, len) => self.merge_array_values( - element_types, - len, - then_condition, - else_condition, - then_value, - else_value, - ), + typ @ Type::Array(_, _) => { + self.merge_array_values(typ, then_condition, else_condition, then_value, else_value) + } // TODO(#1889) Type::Slice(_) => panic!("Cannot return slices from an if expression"), Type::Reference => panic!("Cannot return references from an if expression"), @@ -413,8 +408,7 @@ impl<'f> Context<'f> { /// by creating a new array containing the result of self.merge_values for each element. fn merge_array_values( &mut self, - element_types: Rc, - len: usize, + typ: Type, then_condition: ValueId, else_condition: ValueId, then_value: ValueId, @@ -422,6 +416,11 @@ impl<'f> Context<'f> { ) -> ValueId { let mut merged = im::Vector::new(); + let (element_types, len) = match &typ { + Type::Array(elements, len) => (elements, *len), + _ => panic!("Expected array type"), + }; + for i in 0..len { for (element_index, element_type) in element_types.iter().enumerate() { let index = ((i * element_types.len() + element_index) as u128).into(); @@ -446,7 +445,7 @@ impl<'f> Context<'f> { } } - self.inserter.function.dfg.make_array(merged, element_types) + self.inserter.function.dfg.make_array(merged, typ) } /// Merge two numeric values a and b from separate basic blocks to a single value. This @@ -740,7 +739,7 @@ impl<'f> Context<'f> { mod test { use std::rc::Rc; - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ dfg::DataFlowGraph, function::{Function, RuntimeType}, @@ -1333,8 +1332,10 @@ mod test { let b3 = builder.insert_block(); let element_type = Rc::new(vec![Type::field()]); + let array_type = Type::Array(element_type.clone(), 1); + let zero = builder.field_constant(0_u128); - let zero_array = builder.array_constant(im::Vector::unit(zero), element_type.clone()); + let zero_array = builder.array_constant(im::Vector::unit(zero), array_type); let i_zero = builder.numeric_constant(0_u128, Type::unsigned(32)); let pedersen = builder.import_intrinsic_id(Intrinsic::BlackBox(acvm::acir::BlackBoxFunc::Pedersen)); diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg/branch_analysis.rs b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs similarity index 98% rename from crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg/branch_analysis.rs rename to crates/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs index bed0686e45b..1203d03f562 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/flatten_cfg/branch_analysis.rs +++ b/crates/noirc_evaluator/src/ssa/opt/flatten_cfg/branch_analysis.rs @@ -21,9 +21,7 @@ //! the resulting map from each split block to each join block is returned. use std::collections::HashMap; -use crate::ssa_refactor::ir::{ - basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, -}; +use crate::ssa::ir::{basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function}; /// Returns a `HashMap` mapping blocks that start a branch (i.e. blocks terminated with jmpif) to /// their corresponding blocks that end the branch. @@ -114,7 +112,7 @@ impl<'cfg> Context<'cfg> { #[cfg(test)] mod test { - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{cfg::ControlFlowGraph, function::RuntimeType, map::Id, types::Type}, opt::flatten_cfg::branch_analysis::find_branch_ends, ssa_builder::FunctionBuilder, diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/inlining.rs b/crates/noirc_evaluator/src/ssa/opt/inlining.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/opt/inlining.rs rename to crates/noirc_evaluator/src/ssa/opt/inlining.rs index 430b52ce9f6..d4c118fd3f4 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/inlining.rs +++ b/crates/noirc_evaluator/src/ssa/opt/inlining.rs @@ -6,7 +6,7 @@ use std::collections::{HashMap, HashSet}; use iter_extended::vecmap; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, dfg::InsertInstructionResult, @@ -217,9 +217,9 @@ impl<'function> PerFunctionContext<'function> { Value::ForeignFunction(function) => { self.context.builder.import_foreign_function(function) } - Value::Array { array, element_type } => { + Value::Array { array, typ } => { let elements = array.iter().map(|value| self.translate_value(*value)).collect(); - self.context.builder.array_constant(elements, element_type.clone()) + self.context.builder.array_constant(elements, typ.clone()) } }; @@ -482,7 +482,7 @@ impl<'function> PerFunctionContext<'function> { mod test { use acvm::FieldElement; - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ basic_block::BasicBlockId, function::RuntimeType, diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/mem2reg.rs b/crates/noirc_evaluator/src/ssa/opt/mem2reg.rs similarity index 98% rename from crates/noirc_evaluator/src/ssa_refactor/opt/mem2reg.rs rename to crates/noirc_evaluator/src/ssa/opt/mem2reg.rs index 145ba25f5a5..b9e849bb77c 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/mem2reg.rs +++ b/crates/noirc_evaluator/src/ssa/opt/mem2reg.rs @@ -5,7 +5,7 @@ use std::collections::{BTreeMap, HashMap, HashSet}; use iter_extended::vecmap; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, dfg::DataFlowGraph, @@ -182,7 +182,7 @@ mod tests { use acvm::FieldElement; use im::vector; - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ basic_block::BasicBlockId, dfg::DataFlowGraph, @@ -212,10 +212,11 @@ mod tests { let two = builder.field_constant(FieldElement::one()); let element_type = Rc::new(vec![Type::field()]); - let array = builder.array_constant(vector![one, two], element_type.clone()); + let array_type = Type::Array(element_type, 2); + let array = builder.array_constant(vector![one, two], array_type.clone()); builder.insert_store(v0, array); - let v1 = builder.insert_load(v0, Type::Array(element_type, 2)); + let v1 = builder.insert_load(v0, array_type); let v2 = builder.insert_array_get(v1, one, Type::field()); builder.terminate_with_return(vec![v2]); diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/mod.rs b/crates/noirc_evaluator/src/ssa/opt/mod.rs similarity index 100% rename from crates/noirc_evaluator/src/ssa_refactor/opt/mod.rs rename to crates/noirc_evaluator/src/ssa/opt/mod.rs diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/simplify_cfg.rs b/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/opt/simplify_cfg.rs rename to crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs index 22991e38b94..58259cec90c 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/simplify_cfg.rs +++ b/crates/noirc_evaluator/src/ssa/opt/simplify_cfg.rs @@ -11,7 +11,7 @@ //! Currently, 1 and 4 are unimplemented. use std::collections::HashSet; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, instruction::TerminatorInstruction, @@ -148,7 +148,7 @@ fn try_inline_into_predecessor( #[cfg(test)] mod test { - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{ function::RuntimeType, instruction::{BinaryOp, TerminatorInstruction}, diff --git a/crates/noirc_evaluator/src/ssa_refactor/opt/unrolling.rs b/crates/noirc_evaluator/src/ssa/opt/unrolling.rs similarity index 99% rename from crates/noirc_evaluator/src/ssa_refactor/opt/unrolling.rs rename to crates/noirc_evaluator/src/ssa/opt/unrolling.rs index e5d7d6f0d5c..f6d7c952277 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/opt/unrolling.rs +++ b/crates/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -14,7 +14,7 @@ //! program that will need to be removed by a later simplify cfg pass. use std::collections::{HashMap, HashSet}; -use crate::ssa_refactor::{ +use crate::ssa::{ ir::{ basic_block::BasicBlockId, cfg::ControlFlowGraph, dfg::DataFlowGraph, dom::DominatorTree, function::Function, function_inserter::FunctionInserter, @@ -424,7 +424,7 @@ impl<'f> LoopIteration<'f> { #[cfg(test)] mod tests { - use crate::ssa_refactor::{ + use crate::ssa::{ ir::{function::RuntimeType, instruction::BinaryOp, map::Id, types::Type}, ssa_builder::FunctionBuilder, }; diff --git a/crates/noirc_evaluator/src/ssa_refactor/ssa_builder/mod.rs b/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs similarity index 97% rename from crates/noirc_evaluator/src/ssa_refactor/ssa_builder/mod.rs rename to crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs index d3d9e56b3af..066b5b51199 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ssa_builder/mod.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_builder/mod.rs @@ -1,9 +1,9 @@ -use std::{borrow::Cow, rc::Rc}; +use std::borrow::Cow; use acvm::FieldElement; use noirc_errors::Location; -use crate::ssa_refactor::ir::{ +use crate::ssa::ir::{ basic_block::BasicBlockId, function::{Function, FunctionId}, instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction}, @@ -17,7 +17,6 @@ use super::{ dfg::InsertInstructionResult, function::RuntimeType, instruction::{InstructionId, Intrinsic}, - types::CompositeType, }, ssa_gen::Ssa, }; @@ -115,12 +114,8 @@ impl FunctionBuilder { } /// Insert an array constant into the current function with the given element values. - pub(crate) fn array_constant( - &mut self, - elements: im::Vector, - element_types: Rc, - ) -> ValueId { - self.current_function.dfg.make_array(elements, element_types) + pub(crate) fn array_constant(&mut self, elements: im::Vector, typ: Type) -> ValueId { + self.current_function.dfg.make_array(elements, typ) } /// Returns the type of the given value. @@ -368,7 +363,7 @@ mod tests { use acvm::FieldElement; - use crate::ssa_refactor::ir::{ + use crate::ssa::ir::{ function::RuntimeType, instruction::{Endian, Intrinsic}, map::Id, diff --git a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/context.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/context.rs similarity index 87% rename from crates/noirc_evaluator/src/ssa_refactor/ssa_gen/context.rs rename to crates/noirc_evaluator/src/ssa/ssa_gen/context.rs index 769ee6aa09f..6de804a37b8 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/context.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_gen/context.rs @@ -7,16 +7,16 @@ use iter_extended::vecmap; use noirc_errors::Location; use noirc_frontend::monomorphization::ast::{self, LocalId, Parameters}; use noirc_frontend::monomorphization::ast::{FuncId, Program}; -use noirc_frontend::Signedness; +use noirc_frontend::{BinaryOpKind, Signedness}; -use crate::ssa_refactor::ir::dfg::DataFlowGraph; -use crate::ssa_refactor::ir::function::FunctionId as IrFunctionId; -use crate::ssa_refactor::ir::function::{Function, RuntimeType}; -use crate::ssa_refactor::ir::instruction::BinaryOp; -use crate::ssa_refactor::ir::map::AtomicCounter; -use crate::ssa_refactor::ir::types::{NumericType, Type}; -use crate::ssa_refactor::ir::value::ValueId; -use crate::ssa_refactor::ssa_builder::FunctionBuilder; +use crate::ssa::ir::dfg::DataFlowGraph; +use crate::ssa::ir::function::FunctionId as IrFunctionId; +use crate::ssa::ir::function::{Function, RuntimeType}; +use crate::ssa::ir::instruction::{BinaryOp, Endian, Intrinsic}; +use crate::ssa::ir::map::AtomicCounter; +use crate::ssa::ir::types::{NumericType, Type}; +use crate::ssa::ir::value::ValueId; +use crate::ssa::ssa_builder::FunctionBuilder; use super::value::{Tree, Value, Values}; @@ -177,6 +177,15 @@ impl<'a> FunctionContext<'a> { ast::Type::MutableReference(element) => { Self::map_type_helper(element, &mut |_| f(Type::Reference)) } + ast::Type::FmtString(len, fields) => { + // A format string is represented by multiple values + // The message string, the number of fields to be formatted, and + // then the encapsulated fields themselves + let final_fmt_str_fields = + vec![ast::Type::String(*len), ast::Type::Field, *fields.clone()]; + let fmt_str_tuple = ast::Type::Tuple(final_fmt_str_fields); + Self::map_type_helper(&fmt_str_tuple, f) + } other => Tree::Leaf(f(Self::convert_non_tuple_type(other))), } } @@ -204,9 +213,12 @@ impl<'a> FunctionContext<'a> { ast::Type::Integer(Signedness::Unsigned, bits) => Type::unsigned(*bits), ast::Type::Bool => Type::unsigned(1), ast::Type::String(len) => Type::Array(Rc::new(vec![Type::char()]), *len as usize), + ast::Type::FmtString(_, _) => { + panic!("convert_non_tuple_type called on a fmt string: {typ}") + } ast::Type::Unit => panic!("convert_non_tuple_type called on a unit type"), ast::Type::Tuple(_) => panic!("convert_non_tuple_type called on a tuple: {typ}"), - ast::Type::Function(_, _) => Type::Function, + ast::Type::Function(_, _, _) => Type::Function, ast::Type::Slice(element) => { let element_types = Self::convert_type(element).flatten(); Type::Slice(Rc::new(element_types)) @@ -224,6 +236,46 @@ impl<'a> FunctionContext<'a> { Values::empty() } + /// Insert ssa instructions which computes lhs << rhs by doing lhs*2^rhs + fn insert_shift_left(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { + let base = self.builder.field_constant(FieldElement::from(2_u128)); + let pow = self.pow(base, rhs); + self.builder.insert_binary(lhs, BinaryOp::Mul, pow) + } + + /// Insert ssa instructions which computes lhs << rhs by doing lhs/2^rhs + fn insert_shift_right(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { + let base = self.builder.field_constant(FieldElement::from(2_u128)); + let pow = self.pow(base, rhs); + self.builder.insert_binary(lhs, BinaryOp::Div, pow) + } + + /// Computes lhs^rhs via square&multiply, using the bits decomposition of rhs + fn pow(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { + let typ = self.builder.current_function.dfg.type_of_value(rhs); + if let Type::Numeric(NumericType::Unsigned { bit_size }) = typ { + let to_bits = self.builder.import_intrinsic_id(Intrinsic::ToBits(Endian::Little)); + let length = self.builder.field_constant(FieldElement::from(bit_size as i128)); + let result_types = vec![Type::Array(Rc::new(vec![Type::bool()]), bit_size as usize)]; + let rhs_bits = self.builder.insert_call(to_bits, vec![rhs, length], result_types)[0]; + let one = self.builder.field_constant(FieldElement::one()); + let mut r = one; + for i in 1..bit_size + 1 { + let r1 = self.builder.insert_binary(r, BinaryOp::Mul, r); + let a = self.builder.insert_binary(r1, BinaryOp::Mul, lhs); + let idx = self.builder.field_constant(FieldElement::from((bit_size - i) as i128)); + let b = self.builder.insert_array_get(rhs_bits, idx, Type::field()); + let r2 = self.builder.insert_binary(a, BinaryOp::Mul, b); + let c = self.builder.insert_binary(one, BinaryOp::Sub, b); + let r3 = self.builder.insert_binary(c, BinaryOp::Mul, r1); + r = self.builder.insert_binary(r2, BinaryOp::Add, r3); + } + r + } else { + unreachable!("Value must be unsigned in power operation"); + } + } + /// Insert a binary instruction at the end of the current block. /// Converts the form of the binary instruction as necessary /// (e.g. swapping arguments, inserting a not) to represent it in the IR. @@ -235,17 +287,22 @@ impl<'a> FunctionContext<'a> { mut rhs: ValueId, location: Location, ) -> Values { - let op = convert_operator(operator); - - if op == BinaryOp::Eq && matches!(self.builder.type_of_value(lhs), Type::Array(..)) { - return self.insert_array_equality(lhs, operator, rhs, location); - } - - if operator_requires_swapped_operands(operator) { - std::mem::swap(&mut lhs, &mut rhs); - } - - let mut result = self.builder.set_location(location).insert_binary(lhs, op, rhs); + let mut result = match operator { + BinaryOpKind::ShiftLeft => self.insert_shift_left(lhs, rhs), + BinaryOpKind::ShiftRight => self.insert_shift_right(lhs, rhs), + BinaryOpKind::Equal | BinaryOpKind::NotEqual + if matches!(self.builder.type_of_value(lhs), Type::Array(..)) => + { + return self.insert_array_equality(lhs, operator, rhs, location) + } + _ => { + let op = convert_operator(operator); + if operator_requires_swapped_operands(operator) { + std::mem::swap(&mut lhs, &mut rhs); + } + self.builder.set_location(location).insert_binary(lhs, op, rhs) + } + }; if let Some(max_bit_size) = operator_result_max_bit_size_to_truncate( operator, @@ -584,10 +641,8 @@ impl<'a> FunctionContext<'a> { } fn element_size(&self, array: ValueId) -> FieldElement { - match self.builder.type_of_value(array) { - Type::Array(elements, _) | Type::Slice(elements) => (elements.len() as u128).into(), - t => panic!("Uncaught type error: tried to take element size of non-array type {t}"), - } + let size = self.builder.type_of_value(array).element_size(); + FieldElement::from(size as u128) } /// Given an lhs containing only references, create a store instruction to store each value of @@ -692,7 +747,6 @@ fn operator_result_max_bit_size_to_truncate( /// checking operator_requires_not and operator_requires_swapped_operands /// to represent the full operation correctly. fn convert_operator(op: noirc_frontend::BinaryOpKind) -> BinaryOp { - use noirc_frontend::BinaryOpKind; match op { BinaryOpKind::Add => BinaryOp::Add, BinaryOpKind::Subtract => BinaryOp::Sub, @@ -708,8 +762,9 @@ fn convert_operator(op: noirc_frontend::BinaryOpKind) -> BinaryOp { BinaryOpKind::And => BinaryOp::And, BinaryOpKind::Or => BinaryOp::Or, BinaryOpKind::Xor => BinaryOp::Xor, - BinaryOpKind::ShiftRight => BinaryOp::Shr, - BinaryOpKind::ShiftLeft => BinaryOp::Shl, + BinaryOpKind::ShiftRight | BinaryOpKind::ShiftLeft => unreachable!( + "ICE - bit shift operators do not exist in SSA and should have been replaced" + ), } } diff --git a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/mod.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs similarity index 85% rename from crates/noirc_evaluator/src/ssa_refactor/ssa_gen/mod.rs rename to crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 13e67f26cc5..0c0dd35211b 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/mod.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -2,8 +2,6 @@ mod context; mod program; mod value; -use std::rc::Rc; - pub(crate) use program::Ssa; use context::SharedContext; @@ -16,12 +14,7 @@ use self::{ value::{Tree, Values}, }; -use super::ir::{ - function::RuntimeType, - instruction::BinaryOp, - types::{CompositeType, Type}, - value::ValueId, -}; +use super::ir::{function::RuntimeType, instruction::BinaryOp, types::Type, value::ValueId}; /// Generates SSA for the given monomorphized program. /// @@ -96,8 +89,13 @@ impl<'a> FunctionContext<'a> { self.codegen_expression(expr).into_leaf().eval(self) } - /// Codegen for identifiers - fn codegen_ident(&mut self, ident: &ast::Ident) -> Values { + /// Codegen a reference to an ident. + /// The only difference between this and codegen_ident is that if the variable is mutable + /// as in `let mut var = ...;` the `Value::Mutable` will be returned directly instead of + /// being automatically loaded from. This is needed when taking the reference of a variable + /// to reassign to it. Note that mutable references `let x = &mut ...;` do not require this + /// since they are not automatically loaded from and must be explicitly dereferenced. + fn codegen_ident_reference(&mut self, ident: &ast::Ident) -> Values { match &ident.definition { ast::Definition::Local(id) => self.lookup(*id), ast::Definition::Function(id) => self.get_or_queue_function(*id), @@ -111,12 +109,17 @@ impl<'a> FunctionContext<'a> { } } + /// Codegen an identifier, automatically loading its value if it is mutable. + fn codegen_ident(&mut self, ident: &ast::Ident) -> Values { + self.codegen_ident_reference(ident).map(|value| value.eval(self).into()) + } + fn codegen_literal(&mut self, literal: &ast::Literal) -> Values { match literal { ast::Literal::Array(array) => { let elements = vecmap(&array.contents, |element| self.codegen_expression(element)); - let element_types = Self::convert_type(&array.element_type).flatten(); - self.codegen_array(elements, element_types) + let typ = Self::convert_non_tuple_type(&array.typ); + self.codegen_array(elements, typ) } ast::Literal::Integer(value, typ) => { let typ = Self::convert_non_tuple_type(typ); @@ -129,7 +132,20 @@ impl<'a> FunctionContext<'a> { let elements = vecmap(string.as_bytes(), |byte| { self.builder.numeric_constant(*byte as u128, Type::field()).into() }); - self.codegen_array(elements, vec![Type::char()]) + let typ = Self::convert_non_tuple_type(&ast::Type::String(elements.len() as u64)); + self.codegen_array(elements, typ) + } + ast::Literal::FmtStr(string, number_of_fields, fields) => { + // A caller needs multiple pieces of information to make use of a format string + // The message string, the number of fields to be formatted, and the fields themselves + let string = Expression::Literal(ast::Literal::Str(string.clone())); + let number_of_fields = Expression::Literal(ast::Literal::Integer( + (*number_of_fields as u128).into(), + ast::Type::Field, + )); + let fields = *fields.clone(); + let fmt_str_tuple = &[string, number_of_fields, fields]; + self.codegen_tuple(fmt_str_tuple) } } } @@ -143,7 +159,7 @@ impl<'a> FunctionContext<'a> { /// stored the same as the array [1, 2, 3, 4]. /// /// The value returned from this function is always that of the allocate instruction. - fn codegen_array(&mut self, elements: Vec, element_types: CompositeType) -> Values { + fn codegen_array(&mut self, elements: Vec, typ: Type) -> Values { let mut array = im::Vector::new(); for element in elements { @@ -153,7 +169,7 @@ impl<'a> FunctionContext<'a> { }); } - self.builder.array_constant(array, Rc::new(element_types)).into() + self.builder.array_constant(array, typ).into() } fn codegen_block(&mut self, block: &[Expression]) -> Values { @@ -165,20 +181,21 @@ impl<'a> FunctionContext<'a> { } fn codegen_unary(&mut self, unary: &ast::Unary) -> Values { - let rhs = self.codegen_expression(&unary.rhs); match unary.operator { noirc_frontend::UnaryOp::Not => { + let rhs = self.codegen_expression(&unary.rhs); let rhs = rhs.into_leaf().eval(self); self.builder.insert_not(rhs).into() } noirc_frontend::UnaryOp::Minus => { + let rhs = self.codegen_expression(&unary.rhs); let rhs = rhs.into_leaf().eval(self); let typ = self.builder.type_of_value(rhs); let zero = self.builder.numeric_constant(0u128, typ); self.builder.insert_binary(zero, BinaryOp::Sub, rhs).into() } noirc_frontend::UnaryOp::MutableReference => { - rhs.map(|rhs| { + self.codegen_reference(&unary.rhs).map(|rhs| { match rhs { value::Value::Normal(value) => { let alloc = self.builder.insert_allocate(); @@ -191,7 +208,21 @@ impl<'a> FunctionContext<'a> { } }) } - noirc_frontend::UnaryOp::Dereference => self.dereference(&rhs, &unary.result_type), + noirc_frontend::UnaryOp::Dereference { .. } => { + let rhs = self.codegen_expression(&unary.rhs); + self.dereference(&rhs, &unary.result_type) + } + } + } + + fn codegen_reference(&mut self, expr: &Expression) -> Values { + match expr { + Expression::Ident(ident) => self.codegen_ident_reference(ident), + Expression::ExtractTupleField(tuple, index) => { + let tuple = self.codegen_reference(tuple); + Self::get_field(tuple, *index) + } + other => self.codegen_expression(other), } } diff --git a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/program.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/program.rs similarity index 98% rename from crates/noirc_evaluator/src/ssa_refactor/ssa_gen/program.rs rename to crates/noirc_evaluator/src/ssa/ssa_gen/program.rs index aec0e4262c8..509f778f3b0 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/program.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_gen/program.rs @@ -2,7 +2,7 @@ use std::{collections::BTreeMap, fmt::Display}; use iter_extended::btree_map; -use crate::ssa_refactor::ir::{ +use crate::ssa::ir::{ function::{Function, FunctionId}, map::AtomicCounter, }; diff --git a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/value.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/value.rs similarity index 98% rename from crates/noirc_evaluator/src/ssa_refactor/ssa_gen/value.rs rename to crates/noirc_evaluator/src/ssa/ssa_gen/value.rs index 2d209635610..e7bb515465b 100644 --- a/crates/noirc_evaluator/src/ssa_refactor/ssa_gen/value.rs +++ b/crates/noirc_evaluator/src/ssa/ssa_gen/value.rs @@ -1,7 +1,7 @@ use iter_extended::vecmap; -use crate::ssa_refactor::ir::types::Type; -use crate::ssa_refactor::ir::value::ValueId as IrValueId; +use crate::ssa::ir::types::Type; +use crate::ssa::ir::value::ValueId as IrValueId; use super::context::FunctionContext; diff --git a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/errors.rs b/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/errors.rs deleted file mode 100644 index c90f98e15be..00000000000 --- a/crates/noirc_evaluator/src/ssa_refactor/acir_gen/acir_ir/errors.rs +++ /dev/null @@ -1,62 +0,0 @@ -use acvm::FieldElement; -use noirc_errors::Location; - -use crate::errors::{RuntimeError, RuntimeErrorKind}; - -#[derive(Debug, PartialEq, Eq, Clone)] -pub(crate) enum AcirGenError { - InvalidRangeConstraint { num_bits: u32, location: Option }, - IndexOutOfBounds { index: usize, array_size: usize, location: Option }, - UnsupportedIntegerSize { num_bits: u32, max_num_bits: u32, location: Option }, - BadConstantEquality { lhs: FieldElement, rhs: FieldElement, location: Option }, -} - -impl AcirGenError { - pub(crate) fn message(&self) -> String { - match self { - AcirGenError::InvalidRangeConstraint { num_bits, .. } => { - // Don't apply any constraints if the range is for the maximum number of bits or more. - format!( - "All Witnesses are by default u{num_bits} Applying this type does not apply any constraints.\n We also currently do not allow integers of size more than {num_bits}, this will be handled by BigIntegers.") - } - AcirGenError::IndexOutOfBounds { index, array_size, .. } => { - format!("Index out of bounds, array has size {array_size}, but index was {index}") - } - AcirGenError::UnsupportedIntegerSize { num_bits, max_num_bits, .. } => { - format!("Integer sized {num_bits} is over the max supported size of {max_num_bits}") - } - AcirGenError::BadConstantEquality { lhs, rhs, .. } => { - format!("{lhs} and {rhs} constrained to be equal though they never can be") - } - } - } -} - -impl From for RuntimeError { - fn from(error: AcirGenError) -> Self { - match error { - AcirGenError::InvalidRangeConstraint { num_bits, location } => { - let kind = RuntimeErrorKind::FailedRangeConstraint(num_bits); - RuntimeError::new(kind, location) - } - AcirGenError::IndexOutOfBounds { index, array_size, location } => { - let kind = RuntimeErrorKind::ArrayOutOfBounds { - index: index as u128, - bound: array_size as u128, - }; - RuntimeError::new(kind, location) - } - AcirGenError::UnsupportedIntegerSize { num_bits, max_num_bits, location } => { - let kind = RuntimeErrorKind::UnsupportedIntegerSize { num_bits, max_num_bits }; - RuntimeError::new(kind, location) - } - AcirGenError::BadConstantEquality { lhs: _, rhs: _, location } => { - // We avoid showing the actual lhs and rhs since most of the time they are just 0 - // and 1 respectively. This would confuse users if a constraint such as - // assert(foo < bar) fails with "failed constraint: 0 = 1." - let kind = RuntimeErrorKind::FailedConstraint; - RuntimeError::new(kind, location) - } - } - } -} diff --git a/crates/noirc_frontend/Cargo.toml b/crates/noirc_frontend/Cargo.toml index a9a62673af6..1f902d2d399 100644 --- a/crates/noirc_frontend/Cargo.toml +++ b/crates/noirc_frontend/Cargo.toml @@ -20,6 +20,7 @@ serde.workspace = true serde_json.workspace = true rustc-hash = "1.1.0" small-ord-set = "0.1.3" +regex = "1.9.1" [dev-dependencies] strum = "0.24" diff --git a/crates/noirc_frontend/src/ast/expression.rs b/crates/noirc_frontend/src/ast/expression.rs index e36f5b5d260..b1170ff0ed0 100644 --- a/crates/noirc_frontend/src/ast/expression.rs +++ b/crates/noirc_frontend/src/ast/expression.rs @@ -72,6 +72,10 @@ impl ExpressionKind { ExpressionKind::Literal(Literal::Str(contents)) } + pub fn format_string(contents: String) -> ExpressionKind { + ExpressionKind::Literal(Literal::FmtStr(contents)) + } + pub fn constructor((type_name, fields): (Path, Vec<(Ident, Expression)>)) -> ExpressionKind { ExpressionKind::Constructor(Box::new(ConstructorExpression { type_name, fields })) } @@ -264,6 +268,10 @@ impl BinaryOpKind { BinaryOpKind::Modulo => Token::Percent, } } + + pub fn is_bit_shift(&self) -> bool { + matches!(self, BinaryOpKind::ShiftRight | BinaryOpKind::ShiftLeft) + } } #[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, Clone)] @@ -271,7 +279,14 @@ pub enum UnaryOp { Minus, Not, MutableReference, - Dereference, + + /// If implicitly_added is true, this operation was implicitly added by the compiler for a + /// field dereference. The compiler may undo some of these implicitly added dereferences if + /// the reference later turns out to be needed (e.g. passing a field by reference to a function + /// requiring an &mut parameter). + Dereference { + implicitly_added: bool, + }, } impl UnaryOp { @@ -291,6 +306,7 @@ pub enum Literal { Bool(bool), Integer(FieldElement), Str(String), + FmtStr(String), Unit, } @@ -466,6 +482,7 @@ impl Display for Literal { Literal::Bool(boolean) => write!(f, "{}", if *boolean { "true" } else { "false" }), Literal::Integer(integer) => write!(f, "{}", integer.to_u128()), Literal::Str(string) => write!(f, "\"{string}\""), + Literal::FmtStr(string) => write!(f, "f\"{string}\""), Literal::Unit => write!(f, "()"), } } @@ -496,7 +513,7 @@ impl Display for UnaryOp { UnaryOp::Minus => write!(f, "-"), UnaryOp::Not => write!(f, "!"), UnaryOp::MutableReference => write!(f, "&mut"), - UnaryOp::Dereference => write!(f, "*"), + UnaryOp::Dereference { .. } => write!(f, "*"), } } } diff --git a/crates/noirc_frontend/src/ast/function.rs b/crates/noirc_frontend/src/ast/function.rs index de4e4f6f4d2..02af960f7a8 100644 --- a/crates/noirc_frontend/src/ast/function.rs +++ b/crates/noirc_frontend/src/ast/function.rs @@ -82,7 +82,7 @@ impl From for NoirFunction { Some(Attribute::Foreign(_)) => FunctionKind::LowLevel, Some(Attribute::Test) => FunctionKind::Normal, Some(Attribute::Oracle(_)) => FunctionKind::Oracle, - None => FunctionKind::Normal, + Some(Attribute::Deprecated(_)) | None => FunctionKind::Normal, }; NoirFunction { def: fd, kind } diff --git a/crates/noirc_frontend/src/ast/mod.rs b/crates/noirc_frontend/src/ast/mod.rs index ed73cce486a..6aa373c66a9 100644 --- a/crates/noirc_frontend/src/ast/mod.rs +++ b/crates/noirc_frontend/src/ast/mod.rs @@ -9,6 +9,7 @@ mod function; mod statement; mod structure; mod traits; +mod type_alias; pub use expression::*; pub use function::*; @@ -17,6 +18,7 @@ use noirc_errors::Span; pub use statement::*; pub use structure::*; pub use traits::*; +pub use type_alias::*; use crate::{ parser::{ParserError, ParserErrorReason}, @@ -36,6 +38,7 @@ pub enum UnresolvedType { Bool(CompTime), Expression(UnresolvedTypeExpression), String(Option), + FormatString(UnresolvedTypeExpression, Box), Unit, /// A Named UnresolvedType can be a struct type or a type variable @@ -102,9 +105,10 @@ impl std::fmt::Display for UnresolvedType { Expression(expression) => expression.fmt(f), Bool(is_const) => write!(f, "{is_const}bool"), String(len) => match len { - None => write!(f, "str[]"), - Some(len) => write!(f, "str[{len}]"), + None => write!(f, "str<_>"), + Some(len) => write!(f, "str<{len}>"), }, + FormatString(len, elements) => write!(f, "fmt<{len}, {elements}"), Function(args, ret) => { let args = vecmap(args, ToString::to_string); write!(f, "fn({}) -> {ret}", args.join(", ")) diff --git a/crates/noirc_frontend/src/ast/statement.rs b/crates/noirc_frontend/src/ast/statement.rs index 7292d227c3e..e35394e0729 100644 --- a/crates/noirc_frontend/src/ast/statement.rs +++ b/crates/noirc_frontend/src/ast/statement.rs @@ -456,7 +456,7 @@ impl LValue { })), LValue::Dereference(lvalue) => { ExpressionKind::Prefix(Box::new(crate::PrefixExpression { - operator: crate::UnaryOp::Dereference, + operator: crate::UnaryOp::Dereference { implicitly_added: false }, rhs: lvalue.as_expression(span), })) } diff --git a/crates/noirc_frontend/src/ast/type_alias.rs b/crates/noirc_frontend/src/ast/type_alias.rs new file mode 100644 index 00000000000..76a1e5a7e30 --- /dev/null +++ b/crates/noirc_frontend/src/ast/type_alias.rs @@ -0,0 +1,31 @@ +use crate::{Ident, UnresolvedGenerics, UnresolvedType}; +use iter_extended::vecmap; +use noirc_errors::Span; +use std::fmt::Display; + +/// Ast node for type aliases +#[derive(Clone, Debug)] +pub struct NoirTypeAlias { + pub name: Ident, + pub generics: UnresolvedGenerics, + pub typ: UnresolvedType, + pub span: Span, +} + +impl NoirTypeAlias { + pub fn new( + name: Ident, + generics: UnresolvedGenerics, + typ: UnresolvedType, + span: Span, + ) -> NoirTypeAlias { + NoirTypeAlias { name, generics, typ, span } + } +} + +impl Display for NoirTypeAlias { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let generics = vecmap(&self.generics, |generic| generic.to_string()); + write!(f, "type {}<{}> = {}", self.name, generics.join(", "), self.typ) + } +} diff --git a/crates/noirc_frontend/src/graph/mod.rs b/crates/noirc_frontend/src/graph/mod.rs index 7ebfbae4817..af9216071e6 100644 --- a/crates/noirc_frontend/src/graph/mod.rs +++ b/crates/noirc_frontend/src/graph/mod.rs @@ -4,7 +4,7 @@ // This version is also simpler due to not having macro_defs or proc_macros // XXX: Edition may be reintroduced or some sort of versioning -use std::str::FromStr; +use std::{fmt::Display, str::FromStr}; use fm::FileId; use rustc_hash::{FxHashMap, FxHashSet}; @@ -26,14 +26,25 @@ impl CrateId { } } -#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] pub struct CrateName(SmolStr); +impl Display for CrateName { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.0.fmt(f) + } +} + impl From for String { fn from(crate_name: CrateName) -> Self { crate_name.0.into() } } +impl From<&CrateName> for String { + fn from(crate_name: &CrateName) -> Self { + crate_name.0.clone().into() + } +} /// Creates a new CrateName rejecting any crate name that /// has a character on the blacklist. @@ -66,7 +77,6 @@ pub const CHARACTER_BLACK_LIST: [char; 1] = ['-']; pub enum CrateType { Library, Binary, - Workspace, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs b/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs index 3f30a4990e4..2beebf6871c 100644 --- a/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs +++ b/crates/noirc_frontend/src/hir/def_collector/dc_crate.rs @@ -10,10 +10,10 @@ use crate::hir::resolution::{ }; use crate::hir::type_check::{type_check_func, TypeChecker}; use crate::hir::Context; -use crate::node_interner::{FuncId, NodeInterner, StmtId, StructId}; +use crate::node_interner::{FuncId, NodeInterner, StmtId, StructId, TypeAliasId}; use crate::{ - ExpressionKind, Generics, Ident, LetStatement, NoirFunction, NoirStruct, ParsedModule, Shared, - Type, TypeBinding, UnresolvedGenerics, UnresolvedType, + ExpressionKind, Generics, Ident, LetStatement, Literal, NoirFunction, NoirStruct, + NoirTypeAlias, ParsedModule, Shared, Type, TypeBinding, UnresolvedGenerics, UnresolvedType, }; use fm::FileId; use iter_extended::vecmap; @@ -40,6 +40,13 @@ pub struct UnresolvedStruct { pub struct_def: NoirStruct, } +#[derive(Clone)] +pub struct UnresolvedTypeAlias { + pub file_id: FileId, + pub module_id: LocalModuleId, + pub type_alias_def: NoirTypeAlias, +} + #[derive(Clone)] pub struct UnresolvedGlobal { pub file_id: FileId, @@ -54,6 +61,7 @@ pub struct DefCollector { pub(crate) collected_imports: Vec, pub(crate) collected_functions: Vec, pub(crate) collected_types: HashMap, + pub(crate) collected_type_aliases: HashMap, pub(crate) collected_globals: Vec, pub(crate) collected_impls: ImplMap, } @@ -71,6 +79,7 @@ impl DefCollector { collected_imports: vec![], collected_functions: vec![], collected_types: HashMap::new(), + collected_type_aliases: HashMap::new(), collected_impls: HashMap::new(), collected_globals: vec![], } @@ -152,10 +161,12 @@ impl DefCollector { // // Additionally, we must resolve integer globals before structs since structs may refer to // the values of integer globals as numeric generics. - let (integer_globals, other_globals) = - filter_integer_globals(def_collector.collected_globals); + let (literal_globals, other_globals) = + filter_literal_globals(def_collector.collected_globals); - let mut file_global_ids = resolve_globals(context, integer_globals, crate_id, errors); + let mut file_global_ids = resolve_globals(context, literal_globals, crate_id, errors); + + resolve_type_aliases(context, def_collector.collected_type_aliases, crate_id, errors); // Must resolve structs before we resolve globals. resolve_structs(context, def_collector.collected_types, crate_id, errors); @@ -263,13 +274,15 @@ where } /// Separate the globals Vec into two. The first element in the tuple will be the -/// integer literal globals, and the second will be all other globals. -fn filter_integer_globals( +/// literal globals, except for arrays, and the second will be all other globals. +/// We exclude array literals as they can contain complex types +fn filter_literal_globals( globals: Vec, ) -> (Vec, Vec) { - globals - .into_iter() - .partition(|global| matches!(&global.stmt_def.expression.kind, ExpressionKind::Literal(_))) + globals.into_iter().partition(|global| match &global.stmt_def.expression.kind { + ExpressionKind::Literal(literal) => !matches!(literal, Literal::Array(_)), + _ => false, + }) } fn resolve_globals( @@ -358,6 +371,27 @@ fn resolve_struct_fields( (generics, fields) } +fn resolve_type_aliases( + context: &mut Context, + type_aliases: HashMap, + crate_id: CrateId, + all_errors: &mut Vec, +) { + for (type_id, unresolved_typ) in type_aliases { + let path_resolver = StandardPathResolver::new(ModuleId { + local_id: unresolved_typ.module_id, + krate: crate_id, + }); + let file = unresolved_typ.file_id; + let (typ, generics, errors) = + Resolver::new(&mut context.def_interner, &path_resolver, &context.def_maps, file) + .resolve_type_aliases(unresolved_typ.type_alias_def); + extend_errors(all_errors, file, errors); + + context.def_interner.set_type_alias(type_id, typ, generics); + } +} + fn resolve_impls( interner: &mut NodeInterner, crate_id: CrateId, diff --git a/crates/noirc_frontend/src/hir/def_collector/dc_mod.rs b/crates/noirc_frontend/src/hir/def_collector/dc_mod.rs index 2e478b6c040..9d05539750c 100644 --- a/crates/noirc_frontend/src/hir/def_collector/dc_mod.rs +++ b/crates/noirc_frontend/src/hir/def_collector/dc_mod.rs @@ -3,11 +3,12 @@ use noirc_errors::FileDiagnostic; use crate::{ graph::CrateId, hir::def_collector::dc_crate::UnresolvedStruct, node_interner::StructId, - parser::SubModule, Ident, LetStatement, NoirFunction, NoirStruct, ParsedModule, TypeImpl, + parser::SubModule, Ident, LetStatement, NoirFunction, NoirStruct, NoirTypeAlias, ParsedModule, + TypeImpl, }; use super::{ - dc_crate::{DefCollector, UnresolvedFunctions, UnresolvedGlobal}, + dc_crate::{DefCollector, UnresolvedFunctions, UnresolvedGlobal, UnresolvedTypeAlias}, errors::DefCollectorErrorKind, }; use crate::hir::def_map::{parse_file, LocalModuleId, ModuleData, ModuleId, ModuleOrigin}; @@ -55,6 +56,8 @@ pub fn collect_defs( collector.collect_structs(ast.types, crate_id, errors); + collector.collect_type_aliases(context, ast.type_aliases, errors); + collector.collect_functions(context, ast.functions, errors); collector.collect_impls(context, ast.impls); @@ -183,6 +186,39 @@ impl<'a> ModCollector<'a> { } } + /// Collect any type aliases definitions declared within the ast. + /// Returns a vector of errors if any type aliases were already defined. + fn collect_type_aliases( + &mut self, + context: &mut Context, + type_aliases: Vec, + errors: &mut Vec, + ) { + for type_alias in type_aliases { + let name = type_alias.name.clone(); + + // And store the TypeId -> TypeAlias mapping somewhere it is reachable + let unresolved = UnresolvedTypeAlias { + file_id: self.file_id, + module_id: self.module_id, + type_alias_def: type_alias, + }; + + let type_alias_id = context.def_interner.push_type_alias(&unresolved); + + // Add the type alias to scope so its path can be looked up later + let result = self.def_collector.def_map.modules[self.module_id.0] + .declare_type_alias(name, type_alias_id); + + if let Err((first_def, second_def)) = result { + let err = DefCollectorErrorKind::DuplicateFunction { first_def, second_def }; + errors.push(err.into_file_diagnostic(self.file_id)); + } + + self.def_collector.collected_type_aliases.insert(type_alias_id, unresolved); + } + } + fn collect_submodules( &mut self, context: &mut Context, @@ -223,7 +259,7 @@ impl<'a> ModCollector<'a> { errors: &mut Vec, ) { let child_file_id = - match context.file_manager.resolve_path(self.file_id, &mod_name.0.contents) { + match context.file_manager.find_module(self.file_id, &mod_name.0.contents) { Ok(child_file_id) => child_file_id, Err(_) => { let err = diff --git a/crates/noirc_frontend/src/hir/def_map/item_scope.rs b/crates/noirc_frontend/src/hir/def_map/item_scope.rs index 52201f7ade3..760088a3b7e 100644 --- a/crates/noirc_frontend/src/hir/def_map/item_scope.rs +++ b/crates/noirc_frontend/src/hir/def_map/item_scope.rs @@ -48,6 +48,7 @@ impl ItemScope { ModuleDefId::ModuleId(_) => add_item(&mut self.types), ModuleDefId::FunctionId(_) => add_item(&mut self.values), ModuleDefId::TypeId(_) => add_item(&mut self.types), + ModuleDefId::TypeAliasId(_) => add_item(&mut self.types), ModuleDefId::GlobalId(_) => add_item(&mut self.values), } } diff --git a/crates/noirc_frontend/src/hir/def_map/module_data.rs b/crates/noirc_frontend/src/hir/def_map/module_data.rs index 20906885ad9..5b93d04fea7 100644 --- a/crates/noirc_frontend/src/hir/def_map/module_data.rs +++ b/crates/noirc_frontend/src/hir/def_map/module_data.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use fm::FileId; use crate::{ - node_interner::{FuncId, StmtId, StructId}, + node_interner::{FuncId, StmtId, StructId, TypeAliasId}, Ident, }; @@ -65,6 +65,14 @@ impl ModuleData { self.declare(name, ModuleDefId::TypeId(id)) } + pub fn declare_type_alias( + &mut self, + name: Ident, + id: TypeAliasId, + ) -> Result<(), (Ident, Ident)> { + self.declare(name, id.into()) + } + pub fn declare_child_module( &mut self, name: Ident, diff --git a/crates/noirc_frontend/src/hir/def_map/module_def.rs b/crates/noirc_frontend/src/hir/def_map/module_def.rs index 399ee15700c..b64ced78772 100644 --- a/crates/noirc_frontend/src/hir/def_map/module_def.rs +++ b/crates/noirc_frontend/src/hir/def_map/module_def.rs @@ -1,4 +1,4 @@ -use crate::node_interner::{FuncId, StmtId, StructId}; +use crate::node_interner::{FuncId, StmtId, StructId, TypeAliasId}; use super::ModuleId; @@ -8,6 +8,7 @@ pub enum ModuleDefId { ModuleId(ModuleId), FunctionId(FuncId), TypeId(StructId), + TypeAliasId(TypeAliasId), GlobalId(StmtId), } @@ -26,6 +27,13 @@ impl ModuleDefId { } } + pub fn as_type_alias(&self) -> Option { + match self { + ModuleDefId::TypeAliasId(type_alias_id) => Some(*type_alias_id), + _ => None, + } + } + pub fn as_global(&self) -> Option { match self { ModuleDefId::GlobalId(stmt_id) => Some(*stmt_id), @@ -39,6 +47,7 @@ impl ModuleDefId { match self { ModuleDefId::FunctionId(_) => "function", ModuleDefId::TypeId(_) => "type", + ModuleDefId::TypeAliasId(_) => "type alias", ModuleDefId::ModuleId(_) => "module", ModuleDefId::GlobalId(_) => "global", } @@ -57,6 +66,12 @@ impl From for ModuleDefId { } } +impl From for ModuleDefId { + fn from(fid: TypeAliasId) -> Self { + ModuleDefId::TypeAliasId(fid) + } +} + impl From for ModuleDefId { fn from(stmt_id: StmtId) -> Self { ModuleDefId::GlobalId(stmt_id) @@ -97,6 +112,20 @@ impl TryFromModuleDefId for StructId { } } +impl TryFromModuleDefId for TypeAliasId { + fn try_from(id: ModuleDefId) -> Option { + id.as_type_alias() + } + + fn dummy_id() -> Self { + TypeAliasId::dummy_id() + } + + fn description() -> String { + "type alias".to_string() + } +} + impl TryFromModuleDefId for StmtId { fn try_from(id: ModuleDefId) -> Option { id.as_global() diff --git a/crates/noirc_frontend/src/hir/mod.rs b/crates/noirc_frontend/src/hir/mod.rs index 5937f57a8c7..d6f98e112af 100644 --- a/crates/noirc_frontend/src/hir/mod.rs +++ b/crates/noirc_frontend/src/hir/mod.rs @@ -69,10 +69,7 @@ impl Context { // Check the crate type // We don't panic here to allow users to `evaluate` libraries which will do nothing - if matches!( - self.crate_graph[*crate_id].crate_type, - CrateType::Binary | CrateType::Workspace - ) { + if matches!(self.crate_graph[*crate_id].crate_type, CrateType::Binary) { // All Binaries should have a main function local_crate.main_function() } else { @@ -112,19 +109,6 @@ impl Context { .collect() } - pub fn get_all_test_functions_in_workspace_matching( - &self, - pattern: &str, - ) -> Vec<(String, FuncId)> { - let mut tests = Vec::new(); - - for crate_id in self.crate_graph.iter_keys() { - tests.extend(self.get_all_test_functions_in_crate_matching(&crate_id, pattern)); - } - - tests - } - /// Return a Vec of all `contract` declarations in the source code and the functions they contain pub fn get_all_contracts(&self, crate_id: &CrateId) -> Vec { self.def_map(crate_id) diff --git a/crates/noirc_frontend/src/hir/resolution/errors.rs b/crates/noirc_frontend/src/hir/resolution/errors.rs index 82688928575..e9cf8f31393 100644 --- a/crates/noirc_frontend/src/hir/resolution/errors.rs +++ b/crates/noirc_frontend/src/hir/resolution/errors.rs @@ -74,6 +74,8 @@ pub enum ResolverError { MutableReferenceToArrayElement { span: Span }, #[error("Function is not defined in a contract yet sets is_internal")] ContractFunctionInternalInNormalFunction { span: Span }, + #[error("Numeric constants should be printed without formatting braces")] + NumericConstantInFormatString { name: String, span: Span }, } impl ResolverError { @@ -283,6 +285,11 @@ impl From for Diagnostic { "Non-contract functions cannot be 'internal'".into(), span, ), + ResolverError::NumericConstantInFormatString { name, span } => Diagnostic::simple_error( + format!("cannot find `{name}` in this scope "), + "Numeric constants should be printed without formatting braces".to_string(), + span, + ), } } } diff --git a/crates/noirc_frontend/src/hir/resolution/import.rs b/crates/noirc_frontend/src/hir/resolution/import.rs index 0bc7e065adb..9a6ef9b1b8b 100644 --- a/crates/noirc_frontend/src/hir/resolution/import.rs +++ b/crates/noirc_frontend/src/hir/resolution/import.rs @@ -152,6 +152,7 @@ fn resolve_name_in_module( ModuleDefId::FunctionId(_) => panic!("functions cannot be in the type namespace"), // TODO: If impls are ever implemented, types can be used in a path ModuleDefId::TypeId(id) => id.0, + ModuleDefId::TypeAliasId(_) => panic!("type aliases cannot be used in type namespace"), ModuleDefId::GlobalId(_) => panic!("globals cannot be in the type namespace"), }; diff --git a/crates/noirc_frontend/src/hir/resolution/resolver.rs b/crates/noirc_frontend/src/hir/resolution/resolver.rs index 27fa91a086b..681c853899f 100644 --- a/crates/noirc_frontend/src/hir/resolution/resolver.rs +++ b/crates/noirc_frontend/src/hir/resolution/resolver.rs @@ -12,12 +12,13 @@ // // XXX: Resolver does not check for unused functions use crate::hir_def::expr::{ - HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression, - HirConstructorExpression, HirExpression, HirForExpression, HirIdent, HirIfExpression, - HirIndexExpression, HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess, - HirMethodCallExpression, HirPrefixExpression, + HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCapturedVar, + HirCastExpression, HirConstructorExpression, HirExpression, HirForExpression, HirIdent, + HirIfExpression, HirIndexExpression, HirInfixExpression, HirLambda, HirLiteral, + HirMemberAccess, HirMethodCallExpression, HirPrefixExpression, }; use crate::token::Attribute; +use regex::Regex; use std::collections::{HashMap, HashSet}; use std::rc::Rc; @@ -33,9 +34,9 @@ use crate::{ Statement, }; use crate::{ - ArrayLiteral, ContractFunctionType, Generics, LValue, NoirStruct, Path, Pattern, Shared, - StructType, Type, TypeBinding, TypeVariable, UnaryOp, UnresolvedGenerics, UnresolvedType, - UnresolvedTypeExpression, ERROR_IDENT, + ArrayLiteral, ContractFunctionType, Generics, LValue, NoirStruct, NoirTypeAlias, Path, Pattern, + Shared, StructType, Type, TypeAliasType, TypeBinding, TypeVariable, UnaryOp, + UnresolvedGenerics, UnresolvedType, UnresolvedTypeExpression, ERROR_IDENT, }; use fm::FileId; use iter_extended::vecmap; @@ -57,6 +58,13 @@ type Scope = GenericScope; type ScopeTree = GenericScopeTree; type ScopeForest = GenericScopeForest; +pub struct LambdaContext { + captures: Vec, + /// the index in the scope tree + /// (sometimes being filled by ScopeTree's find method) + scope_index: usize, +} + /// The primary jobs of the Resolver are to validate that every variable found refers to exactly 1 /// definition in scope, and to convert the AST into the HIR. /// @@ -80,12 +88,10 @@ pub struct Resolver<'a> { /// were declared in. generics: Vec<(Rc, TypeVariable, Span)>, - /// Lambdas share the function scope of the function they're defined in, - /// so to identify whether they use any variables from the parent function - /// we keep track of the scope index a variable is declared in. When a lambda - /// is declared we push a scope and set this lambda_index to the scope index. - /// Any variable from a scope less than that must be from the parent function. - lambda_index: usize, + /// When resolving lambda expressions, we need to keep track of the variables + /// that are captured. We do this in order to create the hidden environment + /// parameter for the lambda function. + lambda_stack: Vec, } /// ResolverMetas are tagged onto each definition to track how many times they are used @@ -111,7 +117,7 @@ impl<'a> Resolver<'a> { self_type: None, generics: Vec::new(), errors: Vec::new(), - lambda_index: 0, + lambda_stack: Vec::new(), file, } } @@ -124,10 +130,6 @@ impl<'a> Resolver<'a> { self.errors.push(err); } - fn current_lambda_index(&self) -> usize { - self.scopes.current_scope_index() - } - /// Resolving a function involves interning the metadata /// interning any statements inside of the function /// and interning the function itself @@ -278,25 +280,25 @@ impl<'a> Resolver<'a> { // // If a variable is not found, then an error is logged and a dummy id // is returned, for better error reporting UX - fn find_variable_or_default(&mut self, name: &Ident) -> HirIdent { + fn find_variable_or_default(&mut self, name: &Ident) -> (HirIdent, usize) { self.find_variable(name).unwrap_or_else(|error| { self.push_err(error); let id = DefinitionId::dummy_id(); let location = Location::new(name.span(), self.file); - HirIdent { location, id } + (HirIdent { location, id }, 0) }) } - fn find_variable(&mut self, name: &Ident) -> Result { + fn find_variable(&mut self, name: &Ident) -> Result<(HirIdent, usize), ResolverError> { // Find the definition for this Ident let scope_tree = self.scopes.current_scope_tree(); let variable = scope_tree.find(&name.0.contents); let location = Location::new(name.span(), self.file); - if let Some((variable_found, _)) = variable { + if let Some((variable_found, scope)) = variable { variable_found.num_times_used += 1; let id = variable_found.ident.id; - Ok(HirIdent { location, id }) + Ok((HirIdent { location, id }, scope)) } else { Err(ResolverError::VariableNotDeclared { name: name.0.contents.clone(), @@ -333,11 +335,12 @@ impl<'a> Resolver<'a> { UnresolvedType::FieldElement(comp_time) => Type::FieldElement(comp_time), UnresolvedType::Array(size, elem) => { let elem = Box::new(self.resolve_type_inner(*elem, new_variables)); - if size.is_none() { - return Type::Slice(elem); - } - let resolved_size = self.resolve_array_size(size, new_variables); - Type::Array(Box::new(resolved_size), elem) + let size = if size.is_none() { + Type::NotConstant + } else { + self.resolve_array_size(size, new_variables) + }; + Type::Array(Box::new(size), elem) } UnresolvedType::Expression(expr) => self.convert_expression_type(expr), UnresolvedType::Integer(comp_time, sign, bits) => Type::Integer(comp_time, sign, bits), @@ -346,6 +349,11 @@ impl<'a> Resolver<'a> { let resolved_size = self.resolve_array_size(size, new_variables); Type::String(Box::new(resolved_size)) } + UnresolvedType::FormatString(size, fields) => { + let resolved_size = self.convert_expression_type(size); + let fields = self.resolve_type_inner(*fields, new_variables); + Type::FmtString(Box::new(resolved_size), Box::new(fields)) + } UnresolvedType::Unit => Type::Unit, UnresolvedType::Unspecified => Type::Error, UnresolvedType::Error => Type::Error, @@ -356,7 +364,8 @@ impl<'a> Resolver<'a> { UnresolvedType::Function(args, ret) => { let args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables)); let ret = Box::new(self.resolve_type_inner(*ret, new_variables)); - Type::Function(args, ret) + let env = Box::new(Type::Unit); + Type::Function(args, ret, env) } UnresolvedType::MutableReference(element) => { Type::MutableReference(Box::new(self.resolve_type_inner(*element, new_variables))) @@ -396,22 +405,27 @@ impl<'a> Resolver<'a> { } let span = path.span(); + let mut args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables)); + + if let Some(type_alias_type) = self.lookup_type_alias(path.clone()) { + let expected_generic_count = type_alias_type.generics.len(); + let type_alias_string = type_alias_type.to_string(); + let id = type_alias_type.id; + + self.verify_generics_count(expected_generic_count, &mut args, span, || { + type_alias_string + }); + + return self.interner.get_type_alias(id).get_type(&args); + } + match self.lookup_struct_or_error(path) { Some(struct_type) => { - let mut args = vecmap(args, |arg| self.resolve_type_inner(arg, new_variables)); let expected_generic_count = struct_type.borrow().generics.len(); - if args.len() != expected_generic_count { - self.push_err(ResolverError::IncorrectGenericCount { - span, - struct_type: struct_type.borrow().to_string(), - actual: args.len(), - expected: expected_generic_count, - }); - - // Fix the generic count so we can continue typechecking - args.resize_with(expected_generic_count, || Type::Error); - } + self.verify_generics_count(expected_generic_count, &mut args, span, || { + struct_type.borrow().to_string() + }); Type::Struct(struct_type, args) } @@ -419,6 +433,26 @@ impl<'a> Resolver<'a> { } } + fn verify_generics_count( + &mut self, + expected_count: usize, + args: &mut Vec, + span: Span, + type_name: impl FnOnce() -> String, + ) { + if args.len() != expected_count { + self.errors.push(ResolverError::IncorrectGenericCount { + span, + struct_type: type_name(), + actual: args.len(), + expected: expected_count, + }); + + // Fix the generic count so we can continue typechecking + args.resize_with(expected_count, || Type::Error); + } + } + fn lookup_generic_or_global_type(&mut self, path: &Path) -> Option { if path.segments.len() == 1 { let name = &path.last_segment().0.contents; @@ -485,24 +519,24 @@ impl<'a> Resolver<'a> { } } - fn get_ident_from_path(&mut self, path: Path) -> HirIdent { + fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) { let location = Location::new(path.span(), self.file); let error = match path.as_ident().map(|ident| self.find_variable(ident)) { - Some(Ok(ident)) => return ident, + Some(Ok(found)) => return found, // Try to look it up as a global, but still issue the first error if we fail Some(Err(error)) => match self.lookup_global(path) { - Ok(id) => return HirIdent { location, id }, + Ok(id) => return (HirIdent { location, id }, 0), Err(_) => error, }, None => match self.lookup_global(path) { - Ok(id) => return HirIdent { location, id }, + Ok(id) => return (HirIdent { location, id }, 0), Err(error) => error, }, }; self.push_err(error); let id = DefinitionId::dummy_id(); - HirIdent { location, id } + (HirIdent { location, id }, 0) } /// Translates an UnresolvedType to a Type @@ -510,6 +544,17 @@ impl<'a> Resolver<'a> { self.resolve_type_inner(typ, &mut vec![]) } + pub fn resolve_type_aliases( + mut self, + unresolved: NoirTypeAlias, + ) -> (Type, Generics, Vec) { + let generics = self.add_generics(&unresolved.generics); + self.resolve_local_globals(); + let typ = self.resolve_type(unresolved.typ); + + (typ, generics, self.errors) + } + pub fn take_errors(self) -> Vec { self.errors } @@ -662,7 +707,7 @@ impl<'a> Resolver<'a> { }); } - let mut typ = Type::Function(parameter_types, return_type); + let mut typ = Type::Function(parameter_types, return_type, Box::new(Type::Unit)); if !generics.is_empty() { typ = Type::Forall(generics, Box::new(typ)); @@ -774,22 +819,19 @@ impl<'a> Resolver<'a> { Type::FieldElement(_) | Type::Integer(_, _, _) | Type::Bool(_) - | Type::String(_) | Type::Unit | Type::Error | Type::TypeVariable(_, _) | Type::Constant(_) | Type::NamedGeneric(_, _) + | Type::NotConstant | Type::Forall(_, _) => (), - Type::Array(length, _) => { + Type::Array(length, element_type) => { if let Type::NamedGeneric(type_variable, name) = length.as_ref() { found.insert(name.to_string(), type_variable.clone()); } - } - - Type::Slice(typ) => { - Self::find_numeric_generics_in_type(typ, found); + Self::find_numeric_generics_in_type(element_type, found); } Type::Tuple(fields) => { @@ -797,12 +839,14 @@ impl<'a> Resolver<'a> { Self::find_numeric_generics_in_type(field, found); } } - Type::Function(parameters, return_type) => { + + Type::Function(parameters, return_type, _env) => { for parameter in parameters { Self::find_numeric_generics_in_type(parameter, found); } Self::find_numeric_generics_in_type(return_type, found); } + Type::Struct(struct_type, generics) => { for (i, generic) in generics.iter().enumerate() { if let Type::NamedGeneric(type_variable, name) = generic { @@ -815,6 +859,17 @@ impl<'a> Resolver<'a> { } } Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found), + Type::String(length) => { + if let Type::NamedGeneric(type_variable, name) = length.as_ref() { + found.insert(name.to_string(), type_variable.clone()); + } + } + Type::FmtString(length, fields) => { + if let Type::NamedGeneric(type_variable, name) = length.as_ref() { + found.insert(name.to_string(), type_variable.clone()); + } + Self::find_numeric_generics_in_type(fields, found); + } } } @@ -864,7 +919,7 @@ impl<'a> Resolver<'a> { fn resolve_lvalue(&mut self, lvalue: LValue) -> HirLValue { match lvalue { LValue::Ident(ident) => { - HirLValue::Ident(self.find_variable_or_default(&ident), Type::Error) + HirLValue::Ident(self.find_variable_or_default(&ident).0, Type::Error) } LValue::MemberAccess { object, field_name } => { let object = Box::new(self.resolve_lvalue(*object)); @@ -882,6 +937,39 @@ impl<'a> Resolver<'a> { } } + fn resolve_local_variable(&mut self, hir_ident: HirIdent, var_scope_index: usize) { + let mut transitive_capture_index: Option = None; + + for lambda_index in 0..self.lambda_stack.len() { + if self.lambda_stack[lambda_index].scope_index > var_scope_index { + // Beware: the same variable may be captured multiple times, so we check + // for its presence before adding the capture below. + let pos = self.lambda_stack[lambda_index] + .captures + .iter() + .position(|capture| capture.ident.id == hir_ident.id); + + if pos.is_none() { + self.lambda_stack[lambda_index] + .captures + .push(HirCapturedVar { ident: hir_ident, transitive_capture_index }); + } + + if lambda_index + 1 < self.lambda_stack.len() { + // There is more than one closure between the current scope and + // the scope of the variable, so this is a propagated capture. + // We need to track the transitive capture index as we go up in + // the closure stack. + transitive_capture_index = Some(pos.unwrap_or( + // If this was a fresh capture, we added it to the end of + // the captures vector: + self.lambda_stack[lambda_index].captures.len() - 1, + )); + } + } + } + } + pub fn resolve_expression(&mut self, expr: Expression) -> ExprId { let hir_expr = match expr.kind { ExpressionKind::Literal(literal) => HirExpression::Literal(match literal { @@ -906,6 +994,7 @@ impl<'a> Resolver<'a> { } Literal::Integer(integer) => HirLiteral::Integer(integer), Literal::Str(str) => HirLiteral::Str(str), + Literal::FmtStr(str) => self.resolve_fmt_str_literal(str, expr.span), Literal::Unit => HirLiteral::Unit, }), ExpressionKind::Variable(path) => { @@ -913,7 +1002,20 @@ impl<'a> Resolver<'a> { // Otherwise, then it is referring to an Identifier // This lookup allows support of such statements: let x = foo::bar::SOME_GLOBAL + 10; // If the expression is a singular indent, we search the resolver's current scope as normal. - let hir_ident = self.get_ident_from_path(path); + let (hir_ident, var_scope_index) = self.get_ident_from_path(path); + + if hir_ident.id != DefinitionId::dummy_id() { + match self.interner.definition(hir_ident.id).kind { + DefinitionKind::Function(_) => {} + DefinitionKind::Global(_) => {} + DefinitionKind::GenericType(_) => {} + // We ignore the above definition kinds because only local variables can be captured by closures. + DefinitionKind::Local(_) => { + self.resolve_local_variable(hir_ident, var_scope_index); + } + } + } + HirExpression::Ident(hir_ident) } ExpressionKind::Prefix(prefix) => { @@ -941,6 +1043,7 @@ impl<'a> Resolver<'a> { ExpressionKind::Call(call_expr) => { // Get the span and name of path for error reporting let func = self.resolve_expression(*call_expr.func); + let arguments = vecmap(call_expr.arguments, |arg| self.resolve_expression(arg)); let location = Location::new(expr.span, self.file); HirExpression::Call(HirCallExpression { func, arguments, location }) @@ -1034,8 +1137,9 @@ impl<'a> Resolver<'a> { // We must stay in the same function scope as the parent function to allow for closures // to capture variables. This is currently limited to immutable variables. ExpressionKind::Lambda(lambda) => self.in_new_scope(|this| { - let new_index = this.current_lambda_index(); - let old_index = std::mem::replace(&mut this.lambda_index, new_index); + let scope_index = this.scopes.current_scope_index(); + + this.lambda_stack.push(LambdaContext { captures: Vec::new(), scope_index }); let parameters = vecmap(lambda.parameters, |(pattern, typ)| { let parameter = DefinitionKind::Local(None); @@ -1045,8 +1149,14 @@ impl<'a> Resolver<'a> { let return_type = this.resolve_inferred_type(lambda.return_type); let body = this.resolve_expression(lambda.body); - this.lambda_index = old_index; - HirExpression::Lambda(HirLambda { parameters, return_type, body }) + let lambda_context = this.lambda_stack.pop().unwrap(); + + HirExpression::Lambda(HirLambda { + parameters, + return_type, + body, + captures: lambda_context.captures, + }) }), }; @@ -1236,6 +1346,10 @@ impl<'a> Resolver<'a> { } } + fn lookup_type_alias(&mut self, path: Path) -> Option<&TypeAliasType> { + self.lookup(path).ok().map(|id| self.interner.get_type_alias(id)) + } + fn resolve_path(&mut self, path: Path) -> Result { self.path_resolver.resolve(self.def_maps, path).map_err(ResolverError::PathResolutionError) } @@ -1290,6 +1404,36 @@ impl<'a> Resolver<'a> { let module_id = self.path_resolver.module_id(); module_id.module(self.def_maps).is_contract } + + fn resolve_fmt_str_literal(&mut self, str: String, call_expr_span: Span) -> HirLiteral { + let re = Regex::new(r"\{([a-zA-Z0-9_]+)\}") + .expect("ICE: an invalid regex pattern was used for checking format strings"); + let mut fmt_str_idents = Vec::new(); + for field in re.find_iter(&str) { + let matched_str = field.as_str(); + let ident_name = &matched_str[1..(matched_str.len() - 1)]; + + let scope_tree = self.scopes.current_scope_tree(); + let variable = scope_tree.find(ident_name); + if let Some((old_value, _)) = variable { + old_value.num_times_used += 1; + let expr_id = self.interner.push_expr(HirExpression::Ident(old_value.ident)); + self.interner.push_expr_location(expr_id, call_expr_span, self.file); + fmt_str_idents.push(expr_id); + } else if ident_name.parse::().is_ok() { + self.errors.push(ResolverError::NumericConstantInFormatString { + name: ident_name.to_owned(), + span: call_expr_span, + }); + } else { + self.errors.push(ResolverError::VariableNotDeclared { + name: ident_name.to_owned(), + span: call_expr_span, + }); + } + } + HirLiteral::FmtStr(str, fmt_str_idents) + } } /// Gives an error if a user tries to create a mutable reference @@ -1324,6 +1468,7 @@ pub fn verify_mutable_reference(interner: &NodeInterner, rhs: ExprId) -> Result< #[cfg(test)] mod test { + use core::panic; use std::collections::HashMap; use fm::FileId; @@ -1332,10 +1477,14 @@ mod test { use crate::hir::def_map::{ModuleData, ModuleId, ModuleOrigin}; use crate::hir::resolution::errors::ResolverError; use crate::hir::resolution::import::PathResolutionError; + use crate::hir::resolution::resolver::StmtId; use crate::graph::CrateId; + use crate::hir_def::expr::HirExpression; use crate::hir_def::function::HirFunction; + use crate::hir_def::stmt::HirStatement; use crate::node_interner::{FuncId, NodeInterner}; + use crate::ParsedModule; use crate::{ hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId}, parse_program, Path, @@ -1345,29 +1494,24 @@ mod test { // func_namespace is used to emulate the fact that functions can be imported // and functions can be forward declared - fn resolve_src_code(src: &str, func_namespace: Vec<&str>) -> Vec { + fn init_src_code_resolution( + src: &str, + ) -> (ParsedModule, NodeInterner, HashMap, FileId, TestPathResolver) { let (program, errors) = parse_program(src); - assert!(errors.is_empty()); - - let mut interner = NodeInterner::default(); - - let func_ids = vecmap(&func_namespace, |name| { - let id = interner.push_fn(HirFunction::empty()); - interner.push_function_definition(name.to_string(), id); - id - }); - - let mut path_resolver = TestPathResolver(HashMap::new()); - for (name, id) in func_namespace.into_iter().zip(func_ids) { - path_resolver.insert_func(name.to_owned(), id); + if !errors.is_empty() { + panic!("Unexpected parse errors in test code: {:?}", errors); } + let interner: NodeInterner = NodeInterner::default(); + let mut def_maps: HashMap = HashMap::new(); let file = FileId::default(); let mut modules = arena::Arena::new(); modules.insert(ModuleData::new(None, ModuleOrigin::File(file), false)); + let path_resolver = TestPathResolver(HashMap::new()); + def_maps.insert( CrateId::dummy_id(), CrateDefMap { @@ -1378,10 +1522,30 @@ mod test { }, ); + (program, interner, def_maps, file, path_resolver) + } + + // func_namespace is used to emulate the fact that functions can be imported + // and functions can be forward declared + fn resolve_src_code(src: &str, func_namespace: Vec<&str>) -> Vec { + let (program, mut interner, def_maps, file, mut path_resolver) = + init_src_code_resolution(src); + + let func_ids = vecmap(&func_namespace, |name| { + let id = interner.push_fn(HirFunction::empty()); + interner.push_function_definition(name.to_string(), id); + id + }); + + for (name, id) in func_namespace.into_iter().zip(func_ids) { + path_resolver.insert_func(name.to_owned(), id); + } + let mut errors = Vec::new(); for func in program.functions { let id = interner.push_fn(HirFunction::empty()); interner.push_function_definition(func.name().to_string(), id); + let resolver = Resolver::new(&mut interner, &path_resolver, &def_maps, file); let (_, _, err) = resolver.resolve_function(func, id, ModuleId::dummy_id()); errors.extend(err); @@ -1390,6 +1554,81 @@ mod test { errors } + fn get_program_captures(src: &str) -> Vec> { + let (program, mut interner, def_maps, file, mut path_resolver) = + init_src_code_resolution(src); + + let mut all_captures: Vec> = Vec::new(); + for func in program.functions { + let id = interner.push_fn(HirFunction::empty()); + interner.push_function_definition(func.name().clone().to_string(), id); + path_resolver.insert_func(func.name().to_owned(), id); + + let resolver = Resolver::new(&mut interner, &path_resolver, &def_maps, file); + let (hir_func, _, _) = resolver.resolve_function(func, id, ModuleId::dummy_id()); + + // Iterate over function statements and apply filtering function + parse_statement_blocks( + hir_func.block(&interner).statements(), + &interner, + &mut all_captures, + ); + } + all_captures + } + + fn parse_statement_blocks( + stmts: &[StmtId], + interner: &NodeInterner, + result: &mut Vec>, + ) { + let mut expr: HirExpression; + + for stmt_id in stmts.iter() { + let hir_stmt = interner.statement(stmt_id); + match hir_stmt { + HirStatement::Expression(expr_id) => { + expr = interner.expression(&expr_id); + } + HirStatement::Let(let_stmt) => { + expr = interner.expression(&let_stmt.expression); + } + HirStatement::Assign(assign_stmt) => { + expr = interner.expression(&assign_stmt.expression); + } + HirStatement::Constrain(constr_stmt) => { + expr = interner.expression(&constr_stmt.0); + } + HirStatement::Semi(semi_expr) => { + expr = interner.expression(&semi_expr); + } + HirStatement::Error => panic!("Invalid HirStatement!"), + } + get_lambda_captures(expr, &interner, result); // TODO: dyn filter function as parameter + } + } + + fn get_lambda_captures( + expr: HirExpression, + interner: &NodeInterner, + result: &mut Vec>, + ) { + if let HirExpression::Lambda(lambda_expr) = expr { + let mut cur_capture = Vec::new(); + + for capture in lambda_expr.captures.iter() { + cur_capture.push(interner.definition(capture.ident.id).name.clone()); + } + result.push(cur_capture); + + // Check for other captures recursively within the lambda body + let hir_body_expr = interner.expression(&lambda_expr.body); + if let HirExpression::Block(block_expr) = hir_body_expr.clone() { + parse_statement_blocks(block_expr.statements(), interner, result); + } + } + } + #[test] fn resolve_empty_function() { let src = " @@ -1569,11 +1808,141 @@ mod test { x } "#; + let errors = resolve_src_code(src, vec!["main", "foo"]); + if !errors.is_empty() { + println!("Unexpected errors: {:?}", errors); + assert!(false); // there should be no errors + } + } + + #[test] + fn resolve_basic_closure() { + let src = r#" + fn main(x : Field) -> pub Field { + let closure = |y| y + x; + closure(x) + } + "#; + + let errors = resolve_src_code(src, vec!["main", "foo"]); + if !errors.is_empty() { + panic!("Unexpected errors: {:?}", errors); + } + } + + #[test] + fn resolve_simplified_closure() { + // based on bug https://github.com/noir-lang/noir/issues/1088 + + let src = r#"fn do_closure(x: Field) -> Field { + let y = x; + let ret_capture = || { + y + }; + ret_capture() + } + + fn main(x: Field) { + assert(do_closure(x) == 100); + } + + "#; + let parsed_captures = get_program_captures(src); + let mut expected_captures = vec![]; + expected_captures.push(vec!["y".to_string()]); + assert_eq!(expected_captures, parsed_captures); + } + + #[test] + fn resolve_complex_closures() { + let src = r#" + fn main(x: Field) -> pub Field { + let closure_without_captures = |x| x + x; + let a = closure_without_captures(1); + + let closure_capturing_a_param = |y| y + x; + let b = closure_capturing_a_param(2); + + let closure_capturing_a_local_var = |y| y + b; + let c = closure_capturing_a_local_var(3); + + let closure_with_transitive_captures = |y| { + let d = 5; + let nested_closure = |z| { + let doubly_nested_closure = |w| w + x + b; + a + z + y + d + x + doubly_nested_closure(4) + x + y + }; + let res = nested_closure(5); + res + }; + + a + b + c + closure_with_transitive_captures(6) + } + "#; let errors = resolve_src_code(src, vec!["main", "foo"]); assert!(errors.is_empty()); + if !errors.is_empty() { + println!("Unexpected errors: {:?}", errors); + assert!(false); // there should be no errors + } + + let expected_captures = vec![ + vec![], + vec!["x".to_string()], + vec!["b".to_string()], + vec!["x".to_string(), "b".to_string(), "a".to_string()], + vec![ + "x".to_string(), + "b".to_string(), + "a".to_string(), + "y".to_string(), + "d".to_string(), + ], + vec!["x".to_string(), "b".to_string()], + ]; + + let parsed_captures = get_program_captures(src); + + assert_eq!(expected_captures, parsed_captures); + } + + #[test] + fn resolve_fmt_strings() { + let src = r#" + fn main() { + let string = f"this is i: {i}"; + println(string); + + println(f"I want to print {0}"); + + let new_val = 10; + println(f"randomstring{new_val}{new_val}"); + } + fn println(x : T) -> T { + x + } + "#; + + let errors = resolve_src_code(src, vec!["main", "println"]); + assert!(errors.len() == 2, "Expected 2 errors, got: {:?}", errors); + + for err in errors { + match &err { + ResolverError::VariableNotDeclared { name, .. } => { + assert_eq!(name, "i"); + } + ResolverError::NumericConstantInFormatString { name, .. } => { + assert_eq!(name, "0"); + } + _ => unimplemented!(), + }; + } } + // possible TODO: Create a more sophisticated set of search functions over the HIR, so we can check + // that the correct variables are captured in each closure + fn path_unresolved_error(err: ResolverError, expected_unresolved_path: &str) { match err { ResolverError::PathResolutionError(PathResolutionError::Unresolved(name)) => { diff --git a/crates/noirc_frontend/src/hir/type_check/errors.rs b/crates/noirc_frontend/src/hir/type_check/errors.rs index 3c7e34b5699..4f032503f3d 100644 --- a/crates/noirc_frontend/src/hir/type_check/errors.rs +++ b/crates/noirc_frontend/src/hir/type_check/errors.rs @@ -94,6 +94,8 @@ pub enum TypeCheckError { }, #[error("Cannot infer type of expression, type annotations needed before this point")] TypeAnnotationsNeeded { span: Span }, + #[error("use of deprecated function {name}")] + CallDeprecated { name: String, note: Option, span: Span }, #[error("{0}")] ResolverError(ResolverError), } @@ -205,6 +207,12 @@ impl From for Diagnostic { Diagnostic::simple_error(message, String::new(), span) } + TypeCheckError::CallDeprecated { span, ref note, .. } => { + let primary_message = error.to_string(); + let secondary_message = note.clone().unwrap_or_default(); + + Diagnostic::simple_warning(primary_message, secondary_message, span) + } } } } diff --git a/crates/noirc_frontend/src/hir/type_check/expr.rs b/crates/noirc_frontend/src/hir/type_check/expr.rs index a2ff1c23a63..6c111a1d6a0 100644 --- a/crates/noirc_frontend/src/hir/type_check/expr.rs +++ b/crates/noirc_frontend/src/hir/type_check/expr.rs @@ -10,13 +10,32 @@ use crate::{ }, types::Type, }, - node_interner::{ExprId, FuncId}, - CompTime, Shared, TypeBinding, TypeVariableKind, UnaryOp, + node_interner::{DefinitionKind, ExprId, FuncId}, + token::Attribute::Deprecated, + CompTime, Shared, Signedness, TypeBinding, TypeVariableKind, UnaryOp, }; use super::{errors::TypeCheckError, TypeChecker}; impl<'interner> TypeChecker<'interner> { + fn check_if_deprecated(&mut self, expr: &ExprId) { + if let HirExpression::Ident(expr::HirIdent { location, id }) = + self.interner.expression(expr) + { + if let Some(DefinitionKind::Function(func_id)) = + self.interner.try_definition(id).map(|def| &def.kind) + { + let meta = self.interner.function_meta(func_id); + if let Some(Deprecated(note)) = meta.attributes { + self.errors.push(TypeCheckError::CallDeprecated { + name: self.interner.definition_name(id).to_string(), + note, + span: location.span, + }); + } + } + } + } /// Infers a type for a given expression, and return this type. /// As a side-effect, this function will also remember this type in the NodeInterner /// for the given expr_id key. @@ -48,7 +67,7 @@ impl<'interner> TypeChecker<'interner> { .unwrap_or_else(|| self.interner.next_type_variable()); let arr_type = Type::Array( - Box::new(Type::Constant(arr.len() as u64)), + Box::new(Type::constant_variable(arr.len() as u64, self.interner)), Box::new(first_elem_type.clone()), ); @@ -78,6 +97,12 @@ impl<'interner> TypeChecker<'interner> { } HirLiteral::Array(HirArrayLiteral::Repeated { repeated_element, length }) => { let elem_type = self.check_expression(&repeated_element); + let length = match length { + Type::Constant(length) => { + Type::constant_variable(length, self.interner) + } + other => other, + }; Type::Array(Box::new(length), Box::new(elem_type)) } HirLiteral::Bool(_) => Type::Bool(CompTime::new(self.interner)), @@ -86,6 +111,11 @@ impl<'interner> TypeChecker<'interner> { let len = Type::Constant(string.len() as u64); Type::String(Box::new(len)) } + HirLiteral::FmtStr(string, idents) => { + let len = Type::Constant(string.len() as u64); + let types = vecmap(&idents, |elem| self.check_expression(elem)); + Type::FmtString(Box::new(len), Box::new(Type::Tuple(types))) + } HirLiteral::Unit => Type::Unit, } } @@ -106,10 +136,12 @@ impl<'interner> TypeChecker<'interner> { } HirExpression::Index(index_expr) => self.check_index_expression(index_expr), HirExpression::Call(call_expr) => { + self.check_if_deprecated(&call_expr.func); + let function = self.check_expression(&call_expr.func); let args = vecmap(&call_expr.arguments, |arg| { let typ = self.check_expression(arg); - (typ, self.interner.expr_span(arg)) + (typ, *arg, self.interner.expr_span(arg)) }); let span = self.interner.expr_span(expr_id); self.bind_function_type(function, args, span) @@ -119,14 +151,16 @@ impl<'interner> TypeChecker<'interner> { let method_name = method_call.method.0.contents.as_str(); match self.lookup_method(&object_type, method_name, expr_id) { Some(method_id) => { - let mut args = - vec![(object_type, self.interner.expr_span(&method_call.object))]; + let mut args = vec![( + object_type, + method_call.object, + self.interner.expr_span(&method_call.object), + )]; - let mut arg_types = vecmap(&method_call.arguments, |arg| { + for arg in &method_call.arguments { let typ = self.check_expression(arg); - (typ, self.interner.expr_span(arg)) - }); - args.append(&mut arg_types); + args.push((typ, *arg, self.interner.expr_span(arg))); + } // Desugar the method call into a normal, resolved function call // so that the backend doesn't need to worry about methods @@ -245,6 +279,12 @@ impl<'interner> TypeChecker<'interner> { Type::Tuple(vecmap(&elements, |elem| self.check_expression(elem))) } HirExpression::Lambda(lambda) => { + let captured_vars = + vecmap(lambda.captures, |capture| self.interner.id_type(capture.ident.id)); + + let env_type: Type = + if captured_vars.is_empty() { Type::Unit } else { Type::Tuple(captured_vars) }; + let params = vecmap(lambda.parameters, |(pattern, typ)| { self.bind_pattern(&pattern, typ.clone()); typ @@ -260,7 +300,8 @@ impl<'interner> TypeChecker<'interner> { expr_span: span, } }); - Type::Function(params, Box::new(lambda.return_type)) + + Type::Function(params, Box::new(lambda.return_type), Box::new(env_type)) } }; @@ -272,16 +313,22 @@ impl<'interner> TypeChecker<'interner> { /// if the given object type is already a mutable reference. If not, add one. /// This is used to automatically transform a method call: `foo.bar()` into a function /// call: `bar(&mut foo)`. + /// + /// A notable corner case of this function is where it interacts with auto-deref of `.`. + /// If a field is being mutated e.g. `foo.bar.mutate_bar()` where `foo: &mut Foo`, the compiler + /// will insert a dereference before bar `(*foo).bar.mutate_bar()` which would cause us to + /// mutate a copy of bar rather than a reference to it. We must check for this corner case here + /// and remove the implicitly added dereference operator if we find one. fn try_add_mutable_reference_to_object( &mut self, method_call: &mut HirMethodCallExpression, function_type: &Type, - argument_types: &mut [(Type, noirc_errors::Span)], + argument_types: &mut [(Type, ExprId, noirc_errors::Span)], ) { let expected_object_type = match function_type { - Type::Function(args, _) => args.get(0), + Type::Function(args, _, _) => args.get(0), Type::Forall(_, typ) => match typ.as_ref() { - Type::Function(args, _) => args.get(0), + Type::Function(args, _, _) => args.get(0), typ => unreachable!("Unexpected type for function: {typ}"), }, typ => unreachable!("Unexpected type for function: {typ}"), @@ -298,19 +345,56 @@ impl<'interner> TypeChecker<'interner> { } let new_type = Type::MutableReference(Box::new(actual_type)); - argument_types[0].0 = new_type.clone(); - method_call.object = - self.interner.push_expr(HirExpression::Prefix(HirPrefixExpression { - operator: UnaryOp::MutableReference, - rhs: method_call.object, - })); - self.interner.push_expr_type(&method_call.object, new_type); + + // First try to remove a dereference operator that may have been implicitly + // inserted by a field access expression `foo.bar` on a mutable reference `foo`. + if self.try_remove_implicit_dereference(method_call.object).is_none() { + // If that didn't work, then wrap the whole expression in an `&mut` + method_call.object = + self.interner.push_expr(HirExpression::Prefix(HirPrefixExpression { + operator: UnaryOp::MutableReference, + rhs: method_call.object, + })); + self.interner.push_expr_type(&method_call.object, new_type); + } } } } } + /// Given a method object: `(*foo).bar` of a method call `(*foo).bar.baz()`, remove the + /// implicitly added dereference operator if one is found. + /// + /// Returns Some(()) if a dereference was removed and None otherwise. + fn try_remove_implicit_dereference(&mut self, object: ExprId) -> Option<()> { + match self.interner.expression(&object) { + HirExpression::MemberAccess(access) => { + self.try_remove_implicit_dereference(access.lhs)?; + + // Since we removed a dereference, instead of returning the field directly, + // we expect to be returning a reference to the field, so update the type accordingly. + let current_type = self.interner.id_type(object); + let reference_type = Type::MutableReference(Box::new(current_type)); + self.interner.push_expr_type(&object, reference_type); + Some(()) + } + HirExpression::Prefix(prefix) => match prefix.operator { + UnaryOp::Dereference { implicitly_added: true } => { + // Found a dereference we can remove. Now just replace it with its rhs to remove it. + let rhs = self.interner.expression(&prefix.rhs); + self.interner.replace_expr(&object, rhs); + + let rhs_type = self.interner.id_type(prefix.rhs); + self.interner.push_expr_type(&object, rhs_type); + Some(()) + } + _ => None, + }, + _ => None, + } + } + fn check_index_expression(&mut self, index_expr: expr::HirIndexExpression) -> Type { let index_type = self.check_expression(&index_expr.index); let span = self.interner.expr_span(&index_expr.index); @@ -328,7 +412,6 @@ impl<'interner> TypeChecker<'interner> { // XXX: We can check the array bounds here also, but it may be better to constant fold first // and have ConstId instead of ExprId for constants Type::Array(_, base_type) => *base_type, - Type::Slice(base_type) => *base_type, Type::Error => Type::Error, typ => { let span = self.interner.expr_span(&index_expr.collection); @@ -400,7 +483,7 @@ impl<'interner> TypeChecker<'interner> { &mut self, function_ident_id: &ExprId, func_id: &FuncId, - arguments: Vec<(Type, Span)>, + arguments: Vec<(Type, ExprId, Span)>, span: Span, ) -> Type { if func_id == &FuncId::dummy_id() { @@ -497,7 +580,7 @@ impl<'interner> TypeChecker<'interner> { let arg_type = self.check_expression(&arg); let span = self.interner.expr_span(expr_id); - self.make_subtype_of(&arg_type, ¶m_type, span, || { + self.make_subtype_of(&arg_type, ¶m_type, arg, || { TypeCheckError::TypeMismatch { expected_typ: param_type.to_string(), expr_typ: arg_type.to_string(), @@ -518,7 +601,7 @@ impl<'interner> TypeChecker<'interner> { let dereference_lhs = |this: &mut Self, lhs_type, element| { let old_lhs = *access_lhs; *access_lhs = this.interner.push_expr(HirExpression::Prefix(HirPrefixExpression { - operator: crate::UnaryOp::Dereference, + operator: crate::UnaryOp::Dereference { implicitly_added: true }, rhs: old_lhs, })); this.interner.push_expr_type(&old_lhs, lhs_type); @@ -794,7 +877,41 @@ impl<'interner> TypeChecker<'interner> { } } - fn bind_function_type(&mut self, function: Type, args: Vec<(Type, Span)>, span: Span) -> Type { + fn bind_function_type_impl( + &mut self, + fn_params: &Vec, + fn_ret: &Type, + callsite_args: &Vec<(Type, ExprId, Span)>, + span: Span, + ) -> Type { + if fn_params.len() != callsite_args.len() { + self.errors.push(TypeCheckError::ParameterCountMismatch { + expected: fn_params.len(), + found: callsite_args.len(), + span, + }); + return Type::Error; + } + + for (param, (arg, _, arg_span)) in fn_params.iter().zip(callsite_args) { + arg.make_subtype_of(param, *arg_span, &mut self.errors, || { + TypeCheckError::TypeMismatch { + expected_typ: param.to_string(), + expr_typ: arg.to_string(), + expr_span: *arg_span, + } + }); + } + + fn_ret.clone() + } + + fn bind_function_type( + &mut self, + function: Type, + args: Vec<(Type, ExprId, Span)>, + span: Span, + ) -> Type { // Could do a single unification for the entire function type, but matching beforehand // lets us issue a more precise error on the individual argument that fails to type check. match function { @@ -804,35 +921,18 @@ impl<'interner> TypeChecker<'interner> { } let ret = self.interner.next_type_variable(); - let args = vecmap(args, |(arg, _)| arg); - let expected = Type::Function(args, Box::new(ret.clone())); + let args = vecmap(args, |(arg, _, _)| arg); + let env_type = self.interner.next_type_variable(); + let expected = Type::Function(args, Box::new(ret.clone()), Box::new(env_type)); if let Err(error) = binding.borrow_mut().bind_to(expected, span) { self.errors.push(error); } ret } - Type::Function(parameters, ret) => { - if parameters.len() != args.len() { - self.errors.push(TypeCheckError::ParameterCountMismatch { - expected: parameters.len(), - found: args.len(), - span, - }); - return Type::Error; - } - - for (param, (arg, arg_span)) in parameters.iter().zip(args) { - arg.make_subtype_of(param, arg_span, &mut self.errors, || { - TypeCheckError::TypeMismatch { - expected_typ: param.to_string(), - expr_typ: arg.to_string(), - expr_span: arg_span, - } - }); - } - - *ret + Type::Function(parameters, ret, _env) => { + // ignoring env for subtype on purpose + self.bind_function_type_impl(parameters.as_ref(), ret.as_ref(), args.as_ref(), span) } Type::Error => Type::Error, found => { @@ -869,7 +969,7 @@ impl<'interner> TypeChecker<'interner> { if op.is_bitwise() && (other.is_bindable() || other.is_field()) { let other = other.follow_bindings(); - + let kind = op.kind; // This will be an error if these types later resolve to a Field, or stay // polymorphic as the bit size will be unknown. Delay this error until the function // finishes resolving so we can still allow cases like `let x: u8 = 1 << 2;`. @@ -878,6 +978,12 @@ impl<'interner> TypeChecker<'interner> { Err(TypeCheckError::InvalidBitwiseOperationOnField { span }) } else if other.is_bindable() { Err(TypeCheckError::AmbiguousBitWidth { span }) + } else if kind.is_bit_shift() && other.is_signed() { + Err(TypeCheckError::TypeCannotBeUsed { + typ: other, + place: "bit shift", + span, + }) } else { Ok(()) } @@ -916,8 +1022,14 @@ impl<'interner> TypeChecker<'interner> { span, }); } - let comptime = comptime_x.and(comptime_y, op.location.span); - Ok(Integer(comptime, *sign_x, *bit_width_x)) + if op.is_bit_shift() + && (*sign_x == Signedness::Signed || *sign_y == Signedness::Signed) + { + Err(TypeCheckError::InvalidInfixOp { kind: "Signed integer", span }) + } else { + let comptime = comptime_x.and(comptime_y, op.location.span); + Ok(Integer(comptime, *sign_x, *bit_width_x)) + } } (Integer(..), FieldElement(..)) | (FieldElement(..), Integer(..)) => { Err(TypeCheckError::IntegerAndFieldBinaryOperation { span }) @@ -990,7 +1102,7 @@ impl<'interner> TypeChecker<'interner> { crate::UnaryOp::MutableReference => { Type::MutableReference(Box::new(rhs_type.follow_bindings())) } - crate::UnaryOp::Dereference => { + crate::UnaryOp::Dereference { implicitly_added: _ } => { let element_type = self.interner.next_type_variable(); unify(Type::MutableReference(Box::new(element_type.clone()))); element_type diff --git a/crates/noirc_frontend/src/hir/type_check/mod.rs b/crates/noirc_frontend/src/hir/type_check/mod.rs index a36c1ea67bc..1883c0abf62 100644 --- a/crates/noirc_frontend/src/hir/type_check/mod.rs +++ b/crates/noirc_frontend/src/hir/type_check/mod.rs @@ -63,13 +63,17 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec TypeChecker<'interner> { &mut self, actual: &Type, expected: &Type, - span: Span, + expression: ExprId, make_error: impl FnOnce() -> TypeCheckError, ) { - actual.make_subtype_of(expected, span, &mut self.errors, make_error); + actual.make_subtype_with_coercions( + expected, + expression, + self.interner, + &mut self.errors, + make_error, + ); } } @@ -142,6 +152,7 @@ impl<'interner> TypeChecker<'interner> { #[cfg(test)] mod test { use std::collections::HashMap; + use std::vec; use fm::FileId; use iter_extended::vecmap; @@ -235,7 +246,11 @@ mod test { contract_function_type: None, is_internal: None, is_unconstrained: false, - typ: Type::Function(vec![Type::field(None), Type::field(None)], Box::new(Type::Unit)), + typ: Type::Function( + vec![Type::field(None), Type::field(None)], + Box::new(Type::Unit), + Box::new(Type::Unit), + ), parameters: vec![ Param(Identifier(x), Type::field(None), noirc_abi::AbiVisibility::Private), Param(Identifier(y), Type::field(None), noirc_abi::AbiVisibility::Private), @@ -304,7 +319,29 @@ mod test { type_check_src_code(src, vec![String::from("main"), String::from("foo")]); } + #[test] + fn basic_closure() { + let src = r#" + fn main(x : Field) -> pub Field { + let closure = |y| y + x; + closure(x) + } + "#; + + type_check_src_code(src, vec![String::from("main"), String::from("foo")]); + } + + #[test] + fn closure_with_no_args() { + let src = r#" + fn main(x : Field) -> pub Field { + let closure = || x; + closure() + } + "#; + type_check_src_code(src, vec![String::from("main")]); + } // This is the same Stub that is in the resolver, maybe we can pull this out into a test module and re-use? struct TestPathResolver(HashMap); diff --git a/crates/noirc_frontend/src/hir/type_check/stmt.rs b/crates/noirc_frontend/src/hir/type_check/stmt.rs index 003334ade4e..3130a8616de 100644 --- a/crates/noirc_frontend/src/hir/type_check/stmt.rs +++ b/crates/noirc_frontend/src/hir/type_check/stmt.rs @@ -108,7 +108,7 @@ impl<'interner> TypeChecker<'interner> { }); let span = self.interner.expr_span(&assign_stmt.expression); - self.make_subtype_of(&expr_type, &lvalue_type, span, || { + self.make_subtype_of(&expr_type, &lvalue_type, assign_stmt.expression, || { TypeCheckError::TypeMismatchWithSource { rhs: expr_type.clone(), lhs: lvalue_type.clone(), @@ -192,7 +192,6 @@ impl<'interner> TypeChecker<'interner> { let typ = match result { Type::Array(_, elem_type) => *elem_type, - Type::Slice(elem_type) => *elem_type, Type::Error => Type::Error, other => { // TODO: Need a better span here @@ -260,7 +259,7 @@ impl<'interner> TypeChecker<'interner> { // Now check if LHS is the same type as the RHS // Importantly, we do not coerce any types implicitly let expr_span = self.interner.expr_span(&rhs_expr); - self.make_subtype_of(&expr_type, &annotated_type, expr_span, || { + self.make_subtype_of(&expr_type, &annotated_type, rhs_expr, || { TypeCheckError::TypeMismatch { expected_typ: annotated_type.to_string(), expr_typ: expr_type.to_string(), diff --git a/crates/noirc_frontend/src/hir_def/expr.rs b/crates/noirc_frontend/src/hir_def/expr.rs index 63b7e421dc3..fd980328f5f 100644 --- a/crates/noirc_frontend/src/hir_def/expr.rs +++ b/crates/noirc_frontend/src/hir_def/expr.rs @@ -72,6 +72,10 @@ impl HirBinaryOp { use BinaryOpKind::*; matches!(self.kind, And | Or | Xor | ShiftRight | ShiftLeft) } + + pub fn is_bit_shift(&self) -> bool { + self.kind.is_bit_shift() + } } #[derive(Debug, Clone)] @@ -80,6 +84,7 @@ pub enum HirLiteral { Bool(bool), Integer(FieldElement), Str(String), + FmtStr(String, Vec), Unit, } @@ -192,9 +197,25 @@ impl HirBlockExpression { } } +/// A variable captured inside a closure +#[derive(Debug, Clone)] +pub struct HirCapturedVar { + pub ident: HirIdent, + + /// This will be None when the capture refers to a local variable declared + /// in the same scope as the closure. In a closure-inside-another-closure + /// scenarios, we might have a transitive captures of variables that must + /// be propagated during the construction of each closure. In this case, + /// we store the index of the captured variable in the environment of our + /// direct parent closure. We do this in order to simplify the HIR to AST + /// transformation in the monomorphization pass. + pub transitive_capture_index: Option, +} + #[derive(Debug, Clone)] pub struct HirLambda { pub parameters: Vec<(HirPattern, Type)>, pub return_type: Type, pub body: ExprId, + pub captures: Vec, } diff --git a/crates/noirc_frontend/src/hir_def/function.rs b/crates/noirc_frontend/src/hir_def/function.rs index a69e8bb08b5..225731626f0 100644 --- a/crates/noirc_frontend/src/hir_def/function.rs +++ b/crates/noirc_frontend/src/hir_def/function.rs @@ -180,9 +180,9 @@ impl FuncMeta { /// Gives the (uninstantiated) return type of this function. pub fn return_type(&self) -> &Type { match &self.typ { - Type::Function(_, ret) => ret, + Type::Function(_, ret, _env) => ret, Type::Forall(_, typ) => match typ.as_ref() { - Type::Function(_, ret) => ret, + Type::Function(_, ret, _env) => ret, _ => unreachable!(), }, _ => unreachable!(), diff --git a/crates/noirc_frontend/src/hir_def/types.rs b/crates/noirc_frontend/src/hir_def/types.rs index 143e59f9434..d77b8033ba1 100644 --- a/crates/noirc_frontend/src/hir_def/types.rs +++ b/crates/noirc_frontend/src/hir_def/types.rs @@ -5,13 +5,18 @@ use std::{ rc::Rc, }; -use crate::{hir::type_check::TypeCheckError, node_interner::NodeInterner}; +use crate::{ + hir::type_check::TypeCheckError, + node_interner::{ExprId, NodeInterner, TypeAliasId}, +}; use iter_extended::vecmap; use noirc_abi::AbiType; use noirc_errors::Span; use crate::{node_interner::StructId, Ident, Signedness}; +use super::expr::{HirCallExpression, HirExpression, HirIdent}; + #[derive(Debug, PartialEq, Eq, Clone, Hash)] pub enum Type { /// A primitive Field type, and whether or not it is known at compile-time. @@ -21,9 +26,6 @@ pub enum Type { /// is either a type variable of some kind or a Type::Constant. Array(Box, Box), - /// Slice(E) is a slice with elements of type E. - Slice(Box), - /// A primitive integer type with the given sign, bit count, and whether it is known at compile-time. /// E.g. `u32` would be `Integer(CompTime::No(None), Unsigned, 32)` Integer(CompTime, Signedness, u32), @@ -37,6 +39,10 @@ pub enum Type { /// is either a type variable of some kind or a Type::Constant. String(Box), + /// FmtString(N, Vec) is an array of characters of length N that contains + /// a list of fields specified inside the string by the following regular expression r"\{([\S]+)\}" + FmtString(Box, Box), + /// The unit type `()`. Unit, @@ -64,8 +70,11 @@ pub enum Type { /// like `fn foo(...) {}`. Unlike TypeVariables, they cannot be bound over. NamedGeneric(TypeVariable, Rc), - /// A functions with arguments, and a return type. - Function(Vec, Box), + /// A functions with arguments, a return type and environment. + /// the environment should be `Unit` by default, + /// for closures it should contain a `Tuple` type with the captured + /// variable types. + Function(Vec, Box, Box), /// &mut T MutableReference(Box), @@ -81,6 +90,11 @@ pub enum Type { /// bind to an integer without special checks to bind it to a non-type. Constant(u64), + /// The type of a slice is an array of size NotConstant. + /// The size of an array literal is resolved to this if it ever uses operations + /// involving slices. + NotConstant, + /// The result of some type error. Remembering type errors as their own type variant lets /// us avoid issuing repeat type errors for the same item. For example, a lambda with /// an invalid type would otherwise issue a new error each time it is called @@ -215,6 +229,72 @@ impl std::fmt::Display for StructType { } } +/// Wrap around an unsolved type +#[derive(Debug, Clone, Eq)] +pub struct TypeAliasType { + pub name: Ident, + pub id: TypeAliasId, + pub typ: Type, + pub generics: Generics, + pub span: Span, +} + +impl std::hash::Hash for TypeAliasType { + fn hash(&self, state: &mut H) { + self.id.hash(state); + } +} + +impl PartialEq for TypeAliasType { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl std::fmt::Display for TypeAliasType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name)?; + + if !self.generics.is_empty() { + let generics = vecmap(&self.generics, |(_, binding)| binding.borrow().to_string()); + write!(f, "{}", generics.join(", "))?; + } + + Ok(()) + } +} + +impl TypeAliasType { + pub fn new( + id: TypeAliasId, + name: Ident, + span: Span, + typ: Type, + generics: Generics, + ) -> TypeAliasType { + TypeAliasType { id, typ, name, span, generics } + } + + pub fn set_type_and_generics(&mut self, new_typ: Type, new_generics: Generics) { + assert_eq!(self.typ, Type::Error); + self.typ = new_typ; + self.generics = new_generics; + } + + pub fn get_type(&self, generic_args: &[Type]) -> Type { + assert_eq!(self.generics.len(), generic_args.len()); + + let substitutions = self + .generics + .iter() + .zip(generic_args) + .map(|((old_id, old_var), new)| (*old_id, (old_var.clone(), new.clone()))) + .collect(); + + self.typ.substitute(&substitutions) + } +} + /// A shared, mutable reference to some T. /// Wrapper is required for Hash impl of RefCell. #[derive(Debug, Eq, PartialOrd, Ord)] @@ -275,12 +355,18 @@ pub enum BinaryTypeOperator { pub enum TypeVariableKind { /// Can bind to any type Normal, + /// A generic integer or field type. This is a more specific kind of TypeVariable /// that can only be bound to Type::Field, Type::Integer, or other polymorphic integers. /// This is the type of undecorated integer literals like `46`. Typing them in this way /// allows them to be polymorphic over the actual integer/field type used without requiring /// type annotations on each integer literal. IntegerOrField(CompTime), + + /// A potentially constant array size. This will only bind to itself, Type::NotConstant, or + /// Type::Constant(n) with a matching size. This defaults to Type::Constant(n) if still unbound + /// during monomorphization. + Constant(u64), } /// A TypeVariable is a mutable reference that is either @@ -544,12 +630,18 @@ impl Type { Type::TypeVariable(Shared::new(TypeBinding::Unbound(id)), TypeVariableKind::Normal) } + /// Returns a TypeVariable(_, TypeVariableKind::Constant(length)) to bind to + /// a constant integer for e.g. an array length. + pub fn constant_variable(length: u64, interner: &mut NodeInterner) -> Type { + let id = interner.next_type_variable_id(); + let kind = TypeVariableKind::Constant(length); + Type::TypeVariable(Shared::new(TypeBinding::Unbound(id)), kind) + } + pub fn polymorphic_integer(interner: &mut NodeInterner) -> Type { let id = interner.next_type_variable_id(); - Type::TypeVariable( - Shared::new(TypeBinding::Unbound(id)), - TypeVariableKind::IntegerOrField(CompTime::new(interner)), - ) + let kind = TypeVariableKind::IntegerOrField(CompTime::new(interner)); + Type::TypeVariable(Shared::new(TypeBinding::Unbound(id)), kind) } /// A bit of an awkward name for this function - this function returns @@ -570,6 +662,10 @@ impl Type { matches!(self.follow_bindings(), Type::FieldElement(_)) } + pub fn is_signed(&self) -> bool { + matches!(self.follow_bindings(), Type::Integer(_, Signedness::Signed, _)) + } + fn contains_numeric_typevar(&self, target_id: TypeVariableId) -> bool { // True if the given type is a NamedGeneric with the target_id let named_generic_id_matches_target = |typ: &Type| { @@ -589,26 +685,25 @@ impl Type { Type::FieldElement(_) | Type::Integer(_, _, _) | Type::Bool(_) - | Type::String(_) | Type::Unit | Type::Error | Type::TypeVariable(_, _) | Type::Constant(_) | Type::NamedGeneric(_, _) + | Type::NotConstant | Type::Forall(_, _) => false, Type::Array(length, elem) => { elem.contains_numeric_typevar(target_id) || named_generic_id_matches_target(length) } - Type::Slice(elem) => elem.contains_numeric_typevar(target_id), - Type::Tuple(fields) => { fields.iter().any(|field| field.contains_numeric_typevar(target_id)) } - Type::Function(parameters, return_type) => { + Type::Function(parameters, return_type, env) => { parameters.iter().any(|parameter| parameter.contains_numeric_typevar(target_id)) || return_type.contains_numeric_typevar(target_id) + || env.contains_numeric_typevar(target_id) } Type::Struct(struct_type, generics) => { generics.iter().enumerate().any(|(i, generic)| { @@ -620,6 +715,11 @@ impl Type { }) } Type::MutableReference(element) => element.contains_numeric_typevar(target_id), + Type::String(length) => named_generic_id_matches_target(length), + Type::FmtString(length, elements) => { + elements.contains_numeric_typevar(target_id) + || named_generic_id_matches_target(length) + } } } @@ -642,12 +742,18 @@ impl std::fmt::Display for Type { Type::FieldElement(comp_time) => { write!(f, "{comp_time}Field") } - Type::Array(len, typ) => write!(f, "[{typ}; {len}]"), - Type::Slice(typ) => write!(f, "[{typ}]"), + Type::Array(len, typ) => { + if matches!(len.follow_bindings(), Type::NotConstant) { + write!(f, "[{typ}]") + } else { + write!(f, "[{typ}; {len}]") + } + } Type::Integer(comp_time, sign, num_bits) => match sign { Signedness::Signed => write!(f, "{comp_time}i{num_bits}"), Signedness::Unsigned => write!(f, "{comp_time}u{num_bits}"), }, + Type::TypeVariable(id, TypeVariableKind::Normal) => write!(f, "{}", id.borrow()), Type::TypeVariable(binding, TypeVariableKind::IntegerOrField(_)) => { if let TypeBinding::Unbound(_) = &*binding.borrow() { // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is @@ -658,6 +764,14 @@ impl std::fmt::Display for Type { write!(f, "{}", binding.borrow()) } } + Type::TypeVariable(binding, TypeVariableKind::Constant(n)) => { + if let TypeBinding::Unbound(_) = &*binding.borrow() { + // TypeVariableKind::Constant(n) binds to Type::Constant(n) by default, so just show that. + write!(f, "{n}") + } else { + write!(f, "{}", binding.borrow()) + } + } Type::Struct(s, args) => { let args = vecmap(args, |arg| arg.to_string()); if args.is_empty() { @@ -672,9 +786,11 @@ impl std::fmt::Display for Type { } Type::Bool(comp_time) => write!(f, "{comp_time}bool"), Type::String(len) => write!(f, "str<{len}>"), + Type::FmtString(len, elements) => { + write!(f, "fmtstr<{len}, {elements}>") + } Type::Unit => write!(f, "()"), Type::Error => write!(f, "error"), - Type::TypeVariable(id, TypeVariableKind::Normal) => write!(f, "{}", id.borrow()), Type::NamedGeneric(binding, name) => match &*binding.borrow() { TypeBinding::Bound(binding) => binding.fmt(f), TypeBinding::Unbound(_) if name.is_empty() => write!(f, "_"), @@ -685,13 +801,20 @@ impl std::fmt::Display for Type { let typevars = vecmap(typevars, |(var, _)| var.to_string()); write!(f, "forall {}. {}", typevars.join(" "), typ) } - Type::Function(args, ret) => { - let args = vecmap(args, ToString::to_string); - write!(f, "fn({}) -> {}", args.join(", "), ret) + Type::Function(args, ret, env) => { + let closure_env_text = match **env { + Type::Unit => "".to_string(), + _ => format!(" with closure environment {env}"), + }; + + let args = vecmap(args.iter(), ToString::to_string); + + write!(f, "fn({}) -> {ret}{closure_env_text}", args.join(", ")) } Type::MutableReference(element) => { write!(f, "&mut {element}") } + Type::NotConstant => write!(f, "_"), } } } @@ -770,6 +893,62 @@ impl Type { } } + /// Try to bind a MaybeConstant variable to self, succeeding if self is a Constant, + /// MaybeConstant, or type variable. + pub fn try_bind_to_maybe_constant( + &self, + var: &TypeVariable, + target_length: u64, + ) -> Result<(), SpanKind> { + let target_id = match &*var.borrow() { + TypeBinding::Bound(_) => unreachable!(), + TypeBinding::Unbound(id) => *id, + }; + + match self { + Type::Constant(length) if *length == target_length => { + *var.borrow_mut() = TypeBinding::Bound(self.clone()); + Ok(()) + } + Type::NotConstant => { + *var.borrow_mut() = TypeBinding::Bound(Type::NotConstant); + Ok(()) + } + Type::TypeVariable(binding, kind) => { + let borrow = binding.borrow(); + match &*borrow { + TypeBinding::Bound(typ) => typ.try_bind_to_maybe_constant(var, target_length), + // Avoid infinitely recursive bindings + TypeBinding::Unbound(id) if *id == target_id => Ok(()), + TypeBinding::Unbound(_) => match kind { + TypeVariableKind::Normal => { + drop(borrow); + let clone = Type::TypeVariable( + var.clone(), + TypeVariableKind::Constant(target_length), + ); + *binding.borrow_mut() = TypeBinding::Bound(clone); + Ok(()) + } + TypeVariableKind::Constant(length) if *length == target_length => { + drop(borrow); + let clone = Type::TypeVariable( + var.clone(), + TypeVariableKind::Constant(target_length), + ); + *binding.borrow_mut() = TypeBinding::Bound(clone); + Ok(()) + } + TypeVariableKind::Constant(_) | TypeVariableKind::IntegerOrField(_) => { + Err(SpanKind::None) + } + }, + } + } + _ => Err(SpanKind::None), + } + } + /// Try to bind a PolymorphicInt variable to self, succeeding if self is an integer, field, /// other PolymorphicInt type, or type variable. If use_subtype is true, the CompTime fields /// of each will be checked via sub-typing rather than unification. @@ -930,11 +1109,13 @@ impl Type { /// any unified bindings are on success. fn try_unify(&self, other: &Type, span: Span) -> Result<(), SpanKind> { use Type::*; + use TypeVariableKind as Kind; + match (self, other) { (Error, _) | (_, Error) => Ok(()), - (TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime)), other) - | (other, TypeVariable(binding, TypeVariableKind::IntegerOrField(comptime))) => { + (TypeVariable(binding, Kind::IntegerOrField(comptime)), other) + | (other, TypeVariable(binding, Kind::IntegerOrField(comptime))) => { // If it is already bound, unify against what it is bound to if let TypeBinding::Bound(link) = &*binding.borrow() { return link.try_unify(other, span); @@ -944,7 +1125,8 @@ impl Type { other.try_bind_to_polymorphic_int(binding, comptime, false, span) } - (TypeVariable(binding, _), other) | (other, TypeVariable(binding, _)) => { + (TypeVariable(binding, Kind::Normal), other) + | (other, TypeVariable(binding, Kind::Normal)) => { if let TypeBinding::Bound(link) = &*binding.borrow() { return link.try_unify(other, span); } @@ -952,12 +1134,26 @@ impl Type { other.try_bind_to(binding) } + (TypeVariable(binding, Kind::Constant(length)), other) + | (other, TypeVariable(binding, Kind::Constant(length))) => { + if let TypeBinding::Bound(link) = &*binding.borrow() { + return link.try_unify(other, span); + } + + other.try_bind_to_maybe_constant(binding, *length) + } + (Array(len_a, elem_a), Array(len_b, elem_b)) => { len_a.try_unify(len_b, span)?; elem_a.try_unify(elem_b, span) } - (Slice(elem_a), Slice(elem_b)) => elem_a.try_unify(elem_b, span), + (String(len_a), String(len_b)) => len_a.try_unify(len_b, span), + + (FmtString(len_a, elements_a), FmtString(len_b, elements_b)) => { + len_a.try_unify(len_b, span)?; + elements_a.try_unify(elements_b, span) + } (Tuple(elements_a), Tuple(elements_b)) => { if elements_a.len() != elements_b.len() { @@ -1010,9 +1206,9 @@ impl Type { } } - (Function(params_a, ret_a), Function(params_b, ret_b)) => { + (Function(params_a, ret_a, _env_a), Function(params_b, ret_b, _env_b)) => { if params_a.len() == params_b.len() { - for (a, b) in params_a.iter().zip(params_b) { + for (a, b) in params_a.iter().zip(params_b.iter()) { a.try_unify(b, span)?; } @@ -1048,7 +1244,60 @@ impl Type { } } - fn is_subtype_of(&self, other: &Type, span: Span) -> Result<(), SpanKind> { + /// Similar to `make_subtype_of` but if the check fails this will attempt to coerce the + /// argument to the target type. When this happens, the given expression is wrapped in + /// a new expression to convert its type. E.g. `array` -> `array.as_slice()` + /// + /// Currently the only type coercion in Noir is `[T; N]` into `[T]` via `.as_slice()`. + pub fn make_subtype_with_coercions( + &self, + expected: &Type, + expression: ExprId, + interner: &mut NodeInterner, + errors: &mut Vec, + make_error: impl FnOnce() -> TypeCheckError, + ) { + let span = interner.expr_span(&expression); + if let Err(err_span) = self.is_subtype_of(expected, span) { + if !self.try_array_to_slice_coercion(expected, expression, span, interner) { + Self::issue_errors(expected, err_span, errors, make_error); + } + } + } + + /// Try to apply the array to slice coercion to this given type pair and expression. + /// If self can be converted to target this way, do so and return true to indicate success. + fn try_array_to_slice_coercion( + &self, + target: &Type, + expression: ExprId, + span: Span, + interner: &mut NodeInterner, + ) -> bool { + let this = self.follow_bindings(); + let target = target.follow_bindings(); + + if let (Type::Array(size1, element1), Type::Array(size2, element2)) = (&this, &target) { + let size1 = size1.follow_bindings(); + let size2 = size2.follow_bindings(); + + // If we have an array and our target is a slice + if matches!(size1, Type::Constant(_)) && matches!(size2, Type::NotConstant) { + // Still have to ensure the element types match. + // Don't need to issue an error here if not, it will be done in make_subtype_of_with_coercions + if element1.is_subtype_of(element2, span).is_ok() { + convert_array_expression_to_slice(expression, this, target, interner); + return true; + } + } + } + false + } + + /// Checks if self is a subtype of `other`. Returns Ok(()) if it is and Err(_) if not. + /// Note that this function may permanently bind type variables regardless of whether it + /// returned Ok or Err. + pub fn is_subtype_of(&self, other: &Type, span: Span) -> Result<(), SpanKind> { use Type::*; match (self, other) { (Error, _) | (_, Error) => Ok(()), @@ -1072,14 +1321,14 @@ impl Type { other.try_bind_to_polymorphic_int(binding, comptime, false, span) } - (TypeVariable(binding, _), other) => { + (TypeVariable(binding, TypeVariableKind::Normal), other) => { if let TypeBinding::Bound(link) = &*binding.borrow() { return link.is_subtype_of(other, span); } other.try_bind_to(binding) } - (other, TypeVariable(binding, _)) => { + (other, TypeVariable(binding, TypeVariableKind::Normal)) => { if let TypeBinding::Bound(link) = &*binding.borrow() { return other.is_subtype_of(link, span); } @@ -1087,14 +1336,32 @@ impl Type { other.try_bind_to(binding) } + (TypeVariable(binding, TypeVariableKind::Constant(length)), other) => { + if let TypeBinding::Bound(link) = &*binding.borrow() { + return link.is_subtype_of(other, span); + } + + other.try_bind_to_maybe_constant(binding, *length) + } + (other, TypeVariable(binding, TypeVariableKind::Constant(length))) => { + if let TypeBinding::Bound(link) = &*binding.borrow() { + return other.is_subtype_of(link, span); + } + + other.try_bind_to_maybe_constant(binding, *length) + } + (Array(len_a, elem_a), Array(len_b, elem_b)) => { len_a.is_subtype_of(len_b, span)?; elem_a.is_subtype_of(elem_b, span) } - (Slice(elem_a), Slice(elem_b)) => elem_a.is_subtype_of(elem_b, span), + (String(len_a), String(len_b)) => len_a.is_subtype_of(len_b, span), - (Array(_, elem_a), Slice(elem_b)) => elem_a.is_subtype_of(elem_b, span), + (FmtString(len_a, elements_a), FmtString(len_b, elements_b)) => { + len_a.is_subtype_of(len_b, span)?; + elements_a.is_subtype_of(elements_b, span) + } (Tuple(elements_a), Tuple(elements_b)) => { if elements_a.len() != elements_b.len() { @@ -1146,7 +1413,7 @@ impl Type { } } - (Function(params_a, ret_a), Function(params_b, ret_b)) => { + (Function(params_a, ret_a, _env_a), Function(params_b, ret_b, _env_b)) => { if params_a.len() == params_b.len() { for (a, b) in params_a.iter().zip(params_b) { a.is_subtype_of(b, span)?; @@ -1188,13 +1455,14 @@ impl Type { /// If this type is a Type::Constant (used in array lengths), or is bound /// to a Type::Constant, return the constant as a u64. pub fn evaluate_to_u64(&self) -> Option { - match self { - Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => { - match &*binding.borrow() { - TypeBinding::Bound(binding) => binding.evaluate_to_u64(), - TypeBinding::Unbound(_) => None, - } + if let Some(binding) = self.get_inner_type_variable() { + if let TypeBinding::Bound(binding) = &*binding.borrow() { + return binding.evaluate_to_u64(); } + } + + match self { + Type::TypeVariable(_, TypeVariableKind::Constant(size)) => Some(*size), Type::Array(len, _elem) => len.evaluate_to_u64(), Type::Constant(x) => Some(*x), _ => None, @@ -1233,6 +1501,7 @@ impl Type { .expect("Cannot have variable sized strings as a parameter to main"); AbiType::String { length: size } } + Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"), Type::Error => unreachable!(), Type::Unit => unreachable!(), Type::Constant(_) => unreachable!(), @@ -1246,9 +1515,9 @@ impl Type { Type::TypeVariable(_, _) => unreachable!(), Type::NamedGeneric(..) => unreachable!(), Type::Forall(..) => unreachable!(), - Type::Function(_, _) => unreachable!(), - Type::Slice(_) => unreachable!("slices cannot be used in the abi"), + Type::Function(_, _, _) => unreachable!(), Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"), + Type::NotConstant => unreachable!(), } } @@ -1330,14 +1599,15 @@ impl Type { let element = Box::new(element.substitute(type_bindings)); Type::Array(size, element) } - Type::Slice(element) => { - let element = Box::new(element.substitute(type_bindings)); - Type::Slice(element) - } Type::String(size) => { let size = Box::new(size.substitute(type_bindings)); Type::String(size) } + Type::FmtString(size, fields) => { + let size = Box::new(size.substitute(type_bindings)); + let fields = Box::new(fields.substitute(type_bindings)); + Type::FmtString(size, fields) + } Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => { substitute_binding(binding) } @@ -1360,10 +1630,11 @@ impl Type { let typ = Box::new(typ.substitute(type_bindings)); Type::Forall(typevars.clone(), typ) } - Type::Function(args, ret) => { + Type::Function(args, ret, env) => { let args = vecmap(args, |arg| arg.substitute(type_bindings)); let ret = Box::new(ret.substitute(type_bindings)); - Type::Function(args, ret) + let env = Box::new(env.substitute(type_bindings)); + Type::Function(args, ret, env) } Type::MutableReference(element) => { Type::MutableReference(Box::new(element.substitute(type_bindings))) @@ -1374,6 +1645,7 @@ impl Type { | Type::Bool(_) | Type::Constant(_) | Type::Error + | Type::NotConstant | Type::Unit => self.clone(), } } @@ -1382,8 +1654,12 @@ impl Type { fn occurs(&self, target_id: TypeVariableId) -> bool { match self { Type::Array(len, elem) => len.occurs(target_id) || elem.occurs(target_id), - Type::Slice(element) => element.occurs(target_id), Type::String(len) => len.occurs(target_id), + Type::FmtString(len, fields) => { + let len_occurs = len.occurs(target_id); + let field_occurs = fields.occurs(target_id); + len_occurs || field_occurs + } Type::Struct(_, generic_args) => generic_args.iter().any(|arg| arg.occurs(target_id)), Type::Tuple(fields) => fields.iter().any(|field| field.occurs(target_id)), Type::NamedGeneric(binding, _) | Type::TypeVariable(binding, _) => { @@ -1395,8 +1671,10 @@ impl Type { Type::Forall(typevars, typ) => { !typevars.iter().any(|(id, _)| *id == target_id) && typ.occurs(target_id) } - Type::Function(args, ret) => { - args.iter().any(|arg| arg.occurs(target_id)) || ret.occurs(target_id) + Type::Function(args, ret, env) => { + args.iter().any(|arg| arg.occurs(target_id)) + || ret.occurs(target_id) + || env.occurs(target_id) } Type::MutableReference(element) => element.occurs(target_id), @@ -1405,6 +1683,7 @@ impl Type { | Type::Bool(_) | Type::Constant(_) | Type::Error + | Type::NotConstant | Type::Unit => false, } } @@ -1421,8 +1700,12 @@ impl Type { Array(size, elem) => { Array(Box::new(size.follow_bindings()), Box::new(elem.follow_bindings())) } - Slice(elem) => Slice(Box::new(elem.follow_bindings())), String(size) => String(Box::new(size.follow_bindings())), + FmtString(size, args) => { + let size = Box::new(size.follow_bindings()); + let args = Box::new(args.follow_bindings()); + FmtString(size, args) + } Struct(def, args) => { let args = vecmap(args, |arg| arg.follow_bindings()); Struct(def.clone(), args) @@ -1436,23 +1719,59 @@ impl Type { self.clone() } - Function(args, ret) => { + Function(args, ret, env) => { let args = vecmap(args, |arg| arg.follow_bindings()); let ret = Box::new(ret.follow_bindings()); - Function(args, ret) + let env = Box::new(env.follow_bindings()); + Function(args, ret, env) } + MutableReference(element) => MutableReference(Box::new(element.follow_bindings())), // Expect that this function should only be called on instantiated types Forall(..) => unreachable!(), - FieldElement(_) | Integer(_, _, _) | Bool(_) | Constant(_) | Unit | Error => { - self.clone() - } + FieldElement(_) + | Integer(_, _, _) + | Bool(_) + | Constant(_) + | Unit + | Error + | NotConstant => self.clone(), } } } +/// Wraps a given `expression` in `expression.as_slice()` +fn convert_array_expression_to_slice( + expression: ExprId, + array_type: Type, + target_type: Type, + interner: &mut NodeInterner, +) { + let as_slice_method = interner + .lookup_primitive_method(&array_type, "as_slice") + .expect("Expected 'as_slice' method to be present in Noir's stdlib"); + + let as_slice_id = interner.function_definition_id(as_slice_method); + let location = interner.expr_location(&expression); + let as_slice = HirExpression::Ident(HirIdent { location, id: as_slice_id }); + let func = interner.push_expr(as_slice); + + let arguments = vec![expression]; + let call = HirExpression::Call(HirCallExpression { func, arguments, location }); + let call = interner.push_expr(call); + + interner.push_expr_location(call, location.span, location.file); + interner.push_expr_location(func, location.span, location.file); + + interner.push_expr_type(&call, target_type.clone()); + interner.push_expr_type( + &func, + Type::Function(vec![array_type], Box::new(target_type), Box::new(Type::Unit)), + ); +} + impl BinaryTypeOperator { /// Return the actual rust numeric function associated with this operator pub fn function(self) -> fn(u64, u64) -> u64 { @@ -1465,3 +1784,14 @@ impl BinaryTypeOperator { } } } + +impl TypeVariableKind { + /// Returns the default type this type variable should be bound to if it is still unbound + /// during monomorphization. + pub(crate) fn default_type(&self) -> Type { + match self { + TypeVariableKind::IntegerOrField(_) | TypeVariableKind::Normal => Type::field(None), + TypeVariableKind::Constant(length) => Type::Constant(*length), + } + } +} diff --git a/crates/noirc_frontend/src/lexer/lexer.rs b/crates/noirc_frontend/src/lexer/lexer.rs index 30866be52ce..8a98d5bfa3c 100644 --- a/crates/noirc_frontend/src/lexer/lexer.rs +++ b/crates/noirc_frontend/src/lexer/lexer.rs @@ -102,7 +102,8 @@ impl<'a> Lexer<'a> { Some('}') => self.single_char_token(Token::RightBrace), Some('[') => self.single_char_token(Token::LeftBracket), Some(']') => self.single_char_token(Token::RightBracket), - Some('"') => Ok(self.eat_string_literal()), + Some('"') => Ok(self.eat_string_literal(false)), + Some('f') => self.eat_format_string_or_alpha_numeric(), Some('#') => self.eat_attribute(), Some(ch) if ch.is_ascii_alphanumeric() || ch == '_' => self.eat_alpha_numeric(ch), Some(ch) => { @@ -244,10 +245,7 @@ impl<'a> Lexer<'a> { } self.next_char(); - let (word, start, end) = self.eat_while(None, |ch| { - (ch.is_ascii_alphabetic() || ch.is_numeric() || ch == '_' || ch == '(' || ch == ')') - && (ch != ']') - }); + let (word, start, end) = self.eat_while(None, |ch| ch != ']'); if !self.peek_char_is(']') { return Err(LexerErrorKind::UnexpectedCharacter { @@ -310,13 +308,23 @@ impl<'a> Lexer<'a> { Ok(integer_token.into_span(start, end)) } - fn eat_string_literal(&mut self) -> SpannedToken { + fn eat_string_literal(&mut self, is_format_string: bool) -> SpannedToken { let (str_literal, start_span, end_span) = self.eat_while(None, |ch| ch != '"'); - let str_literal_token = Token::Str(str_literal); + let str_literal_token = + if is_format_string { Token::FmtStr(str_literal) } else { Token::Str(str_literal) }; self.next_char(); // Advance past the closing quote str_literal_token.into_span(start_span, end_span) } + fn eat_format_string_or_alpha_numeric(&mut self) -> SpannedTokenResult { + if self.peek_char_is('"') { + self.next_char(); + Ok(self.eat_string_literal(true)) + } else { + self.eat_alpha_numeric('f') + } + } + fn parse_comment(&mut self) -> SpannedTokenResult { let _ = self.eat_while(None, |ch| ch != '\n'); self.next_token() @@ -427,6 +435,24 @@ fn invalid_attribute() { assert!(token.is_err()); } +#[test] +fn deprecated_attribute() { + let input = r#"#[deprecated]"#; + let mut lexer = Lexer::new(input); + + let token = lexer.next().unwrap().unwrap(); + assert_eq!(token.token(), &Token::Attribute(Attribute::Deprecated(None))); +} + +#[test] +fn deprecated_attribute_with_note() { + let input = r#"#[deprecated("hello")]"#; + let mut lexer = Lexer::new(input); + + let token = lexer.next().unwrap().unwrap(); + assert_eq!(token.token(), &Token::Attribute(Attribute::Deprecated("hello".to_string().into()))); +} + #[test] fn test_custom_gate_syntax() { let input = "#[foreign(sha256)]#[foreign(blake2s)]#[builtin(sum)]"; diff --git a/crates/noirc_frontend/src/lexer/token.rs b/crates/noirc_frontend/src/lexer/token.rs index a58a9cbe249..3ef1d2a5dde 100644 --- a/crates/noirc_frontend/src/lexer/token.rs +++ b/crates/noirc_frontend/src/lexer/token.rs @@ -15,6 +15,7 @@ pub enum Token { Int(FieldElement), Bool(bool), Str(String), + FmtStr(String), Keyword(Keyword), IntType(IntType), Attribute(Attribute), @@ -145,6 +146,7 @@ impl fmt::Display for Token { Token::Int(n) => write!(f, "{}", n.to_u128()), Token::Bool(b) => write!(f, "{b}"), Token::Str(ref b) => write!(f, "{b}"), + Token::FmtStr(ref b) => write!(f, "f{b}"), Token::Keyword(k) => write!(f, "{k}"), Token::Attribute(ref a) => write!(f, "{a}"), Token::IntType(ref i) => write!(f, "{i}"), @@ -212,7 +214,7 @@ impl Token { pub fn kind(&self) -> TokenKind { match *self { Token::Ident(_) => TokenKind::Ident, - Token::Int(_) | Token::Bool(_) | Token::Str(_) => TokenKind::Literal, + Token::Int(_) | Token::Bool(_) | Token::Str(_) | Token::FmtStr(_) => TokenKind::Literal, Token::Keyword(_) => TokenKind::Keyword, Token::Attribute(_) => TokenKind::Attribute, ref tok => TokenKind::Token(tok.clone()), @@ -322,6 +324,7 @@ pub enum Attribute { Foreign(String), Builtin(String), Oracle(String), + Deprecated(Option), Test, } @@ -332,6 +335,8 @@ impl fmt::Display for Attribute { Attribute::Builtin(ref k) => write!(f, "#[builtin({k})]"), Attribute::Oracle(ref k) => write!(f, "#[oracle({k})]"), Attribute::Test => write!(f, "#[test]"), + Attribute::Deprecated(None) => write!(f, "#[deprecated]"), + Attribute::Deprecated(Some(ref note)) => write!(f, r#"#[deprecated("{note}")]"#), } } } @@ -345,29 +350,52 @@ impl Attribute { .filter(|string_segment| !string_segment.is_empty()) .collect(); - if word_segments.len() != 2 { - if word_segments.len() == 1 && word_segments[0] == "test" { - return Ok(Token::Attribute(Attribute::Test)); - } else { - return Err(LexerErrorKind::MalformedFuncAttribute { - span, - found: word.to_owned(), - }); - } - } - - let attribute_type = word_segments[0]; - let attribute_name = word_segments[1]; + let validate = |slice: &str| { + let is_valid = slice + .chars() + .all(|ch| { + ch.is_ascii_alphabetic() + || ch.is_numeric() + || ch == '_' + || ch == '(' + || ch == ')' + }) + .then_some(()); + + is_valid.ok_or(LexerErrorKind::MalformedFuncAttribute { span, found: word.to_owned() }) + }; - let tok = match attribute_type { - "foreign" => Token::Attribute(Attribute::Foreign(attribute_name.to_string())), - "builtin" => Token::Attribute(Attribute::Builtin(attribute_name.to_string())), - "oracle" => Token::Attribute(Attribute::Oracle(attribute_name.to_string())), + let attribute = match &word_segments[..] { + ["foreign", name] => { + validate(name)?; + Attribute::Foreign(name.to_string()) + } + ["builtin", name] => { + validate(name)?; + Attribute::Builtin(name.to_string()) + } + ["oracle", name] => { + validate(name)?; + Attribute::Oracle(name.to_string()) + } + ["deprecated"] => Attribute::Deprecated(None), + ["deprecated", name] => { + if !name.starts_with('"') && !name.ends_with('"') { + return Err(LexerErrorKind::MalformedFuncAttribute { + span, + found: word.to_owned(), + }); + } + + Attribute::Deprecated(name.trim_matches('"').to_string().into()) + } + ["test"] => Attribute::Test, _ => { return Err(LexerErrorKind::MalformedFuncAttribute { span, found: word.to_owned() }) } }; - Ok(tok) + + Ok(Token::Attribute(attribute)) } pub fn builtin(self) -> Option { @@ -399,7 +427,8 @@ impl AsRef for Attribute { Attribute::Foreign(string) => string, Attribute::Builtin(string) => string, Attribute::Oracle(string) => string, - Attribute::Test => "", + Attribute::Deprecated(Some(string)) => string, + Attribute::Test | Attribute::Deprecated(None) => "", } } } @@ -424,6 +453,7 @@ pub enum Keyword { Field, Fn, For, + FormatString, Global, If, Impl, @@ -462,6 +492,7 @@ impl fmt::Display for Keyword { Keyword::Field => write!(f, "Field"), Keyword::Fn => write!(f, "fn"), Keyword::For => write!(f, "for"), + Keyword::FormatString => write!(f, "fmtstr"), Keyword::Global => write!(f, "global"), Keyword::If => write!(f, "if"), Keyword::Impl => write!(f, "impl"), @@ -503,6 +534,7 @@ impl Keyword { "Field" => Keyword::Field, "fn" => Keyword::Fn, "for" => Keyword::For, + "fmtstr" => Keyword::FormatString, "global" => Keyword::Global, "if" => Keyword::If, "impl" => Keyword::Impl, diff --git a/crates/noirc_frontend/src/monomorphization/ast.rs b/crates/noirc_frontend/src/monomorphization/ast.rs index 7cac2ed8e4f..33c3bbebff4 100644 --- a/crates/noirc_frontend/src/monomorphization/ast.rs +++ b/crates/noirc_frontend/src/monomorphization/ast.rs @@ -29,7 +29,6 @@ pub enum Expression { Tuple(Vec), ExtractTupleField(Box, usize), Call(Call), - Let(Let), Constrain(Box, Location), Assign(Assign), @@ -83,6 +82,7 @@ pub enum Literal { Integer(FieldElement, Type), Bool(bool), Str(String), + FmtStr(String, u64, Box), } #[derive(Debug, Clone)] @@ -102,6 +102,12 @@ pub struct Binary { pub location: Location, } +#[derive(Debug, Clone)] +pub struct Lambda { + pub function: Ident, + pub env: Ident, +} + #[derive(Debug, Clone)] pub struct If { pub condition: Box, @@ -119,7 +125,7 @@ pub struct Cast { #[derive(Debug, Clone)] pub struct ArrayLiteral { pub contents: Vec, - pub element_type: Type, + pub typ: Type, } #[derive(Debug, Clone)] @@ -207,11 +213,12 @@ pub enum Type { Integer(Signedness, /*bits:*/ u32), // u32 = Integer(unsigned, 32) Bool, String(/*len:*/ u64), // String(4) = str[4] + FmtString(/*len:*/ u64, Box), Unit, Tuple(Vec), Slice(Box), MutableReference(Box), - Function(/*args:*/ Vec, /*ret:*/ Box), + Function(/*args:*/ Vec, /*ret:*/ Box, /*env:*/ Box), } impl Type { @@ -313,15 +320,22 @@ impl std::fmt::Display for Type { Signedness::Signed => write!(f, "i{bits}"), }, Type::Bool => write!(f, "bool"), - Type::String(len) => write!(f, "str[{len}]"), + Type::String(len) => write!(f, "str<{len}>"), + Type::FmtString(len, elements) => { + write!(f, "fmtstr<{len}, {elements}>") + } Type::Unit => write!(f, "()"), Type::Tuple(elements) => { let elements = vecmap(elements, ToString::to_string); write!(f, "({})", elements.join(", ")) } - Type::Function(args, ret) => { + Type::Function(args, ret, env) => { let args = vecmap(args, ToString::to_string); - write!(f, "fn({}) -> {}", args.join(", "), ret) + let closure_env_text = match **env { + Type::Unit => "".to_string(), + _ => format!(" with closure environment {env}"), + }; + write!(f, "fn({}) -> {}{}", args.join(", "), ret, closure_env_text) } Type::Slice(element) => write!(f, "[{element}"), Type::MutableReference(element) => write!(f, "&mut {element}"), diff --git a/crates/noirc_frontend/src/monomorphization/mod.rs b/crates/noirc_frontend/src/monomorphization/mod.rs index d9ee9666e3c..c8167baf6bb 100644 --- a/crates/noirc_frontend/src/monomorphization/mod.rs +++ b/crates/noirc_frontend/src/monomorphization/mod.rs @@ -19,11 +19,11 @@ use crate::{ expr::*, function::{FuncMeta, Param, Parameters}, stmt::{HirAssignStatement, HirLValue, HirLetStatement, HirPattern, HirStatement}, + types, }, node_interner::{self, DefinitionKind, NodeInterner, StmtId}, token::Attribute, - CompTime, ContractFunctionType, FunctionKind, Type, TypeBinding, TypeBindings, - TypeVariableKind, + ContractFunctionType, FunctionKind, Type, TypeBinding, TypeBindings, TypeVariableKind, }; use self::ast::{Definition, FuncId, Function, LocalId, Program}; @@ -31,6 +31,11 @@ use self::ast::{Definition, FuncId, Function, LocalId, Program}; pub mod ast; pub mod printer; +struct LambdaContext { + env_ident: Box, + captures: Vec, +} + /// The context struct for the monomorphization pass. /// /// This struct holds the FIFO queue of functions to monomorphize, which is added to @@ -59,6 +64,8 @@ struct Monomorphizer<'interner> { /// Used to reference existing definitions in the HIR interner: &'interner NodeInterner, + lambda_envs_stack: Vec, + next_local_id: u32, next_function_id: u32, } @@ -104,6 +111,7 @@ impl<'interner> Monomorphizer<'interner> { next_local_id: 0, next_function_id: 0, interner, + lambda_envs_stack: Vec::new(), } } @@ -262,6 +270,14 @@ impl<'interner> Monomorphizer<'interner> { match self.interner.expression(&expr) { HirExpression::Ident(ident) => self.ident(ident, expr), HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)), + HirExpression::Literal(HirLiteral::FmtStr(contents, idents)) => { + let fields = vecmap(idents, |ident| self.expr(ident)); + Literal(FmtStr( + contents, + fields.len() as u64, + Box::new(ast::Expression::Tuple(fields)), + )) + } HirExpression::Literal(HirLiteral::Bool(value)) => Literal(Bool(value)), HirExpression::Literal(HirLiteral::Integer(value)) => { let typ = Self::convert_type(&self.interner.id_type(expr)); @@ -270,7 +286,7 @@ impl<'interner> Monomorphizer<'interner> { HirExpression::Literal(HirLiteral::Array(array)) => match array { HirArrayLiteral::Standard(array) => self.standard_array(expr, array), HirArrayLiteral::Repeated { repeated_element, length } => { - self.repeated_array(repeated_element, length) + self.repeated_array(expr, repeated_element, length) } }, HirExpression::Literal(HirLiteral::Unit) => ast::Expression::Block(vec![]), @@ -341,7 +357,7 @@ impl<'interner> Monomorphizer<'interner> { } HirExpression::Constructor(constructor) => self.constructor(constructor, expr), - HirExpression::Lambda(lambda) => self.lambda(lambda), + HirExpression::Lambda(lambda) => self.lambda(lambda, expr), HirExpression::MethodCall(_) => { unreachable!("Encountered HirExpression::MethodCall during monomorphization") @@ -355,25 +371,26 @@ impl<'interner> Monomorphizer<'interner> { array: node_interner::ExprId, array_elements: Vec, ) -> ast::Expression { - let element_type = - Self::convert_type(&unwrap_array_element_type(&self.interner.id_type(array))); + let typ = Self::convert_type(&self.interner.id_type(array)); let contents = vecmap(array_elements, |id| self.expr(id)); - ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, element_type })) + ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })) } fn repeated_array( &mut self, + array: node_interner::ExprId, repeated_element: node_interner::ExprId, length: HirType, ) -> ast::Expression { - let element_type = Self::convert_type(&self.interner.id_type(repeated_element)); + let typ = Self::convert_type(&self.interner.id_type(array)); + let contents = self.expr(repeated_element); let length = length .evaluate_to_u64() .expect("Length of array is unknown when evaluating numeric generic"); let contents = vec![contents; length as usize]; - ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, element_type })) + ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents, typ })) } fn index(&mut self, id: node_interner::ExprId, index: HirIndexExpression) -> ast::Expression { @@ -533,6 +550,15 @@ impl<'interner> Monomorphizer<'interner> { ast::Expression::Block(definitions) } + /// Find a captured variable in the innermost closure + fn lookup_captured(&mut self, id: node_interner::DefinitionId) -> Option { + let ctx = self.lambda_envs_stack.last()?; + ctx.captures + .iter() + .position(|capture| capture.ident.id == id) + .map(|index| ast::Expression::ExtractTupleField(ctx.env_ident.clone(), index)) + } + /// A local (ie non-global) ident only fn local_ident(&mut self, ident: &HirIdent) -> Option { let definition = self.interner.definition(ident.id); @@ -556,14 +582,25 @@ impl<'interner> Monomorphizer<'interner> { let definition = self.lookup_function(*func_id, expr_id, &typ); let typ = Self::convert_type(&typ); - let ident = ast::Ident { location, mutable, definition, name, typ }; - ast::Expression::Ident(ident) + let ident = ast::Ident { location, mutable, definition, name, typ: typ.clone() }; + let ident_expression = ast::Expression::Ident(ident); + if self.is_function_closure_type(&typ) { + ast::Expression::Tuple(vec![ + ast::Expression::ExtractTupleField( + Box::new(ident_expression.clone()), + 0usize, + ), + ast::Expression::ExtractTupleField(Box::new(ident_expression), 1usize), + ]) + } else { + ident_expression + } } DefinitionKind::Global(expr_id) => self.expr(*expr_id), - DefinitionKind::Local(_) => { + DefinitionKind::Local(_) => self.lookup_captured(ident.id).unwrap_or_else(|| { let ident = self.local_ident(&ident).unwrap(); ast::Expression::Ident(ident) - } + }), DefinitionKind::GenericType(type_variable) => { let value = match &*type_variable.borrow() { TypeBinding::Unbound(_) => { @@ -587,36 +624,57 @@ impl<'interner> Monomorphizer<'interner> { HirType::Integer(_, sign, bits) => ast::Type::Integer(*sign, *bits), HirType::Bool(_) => ast::Type::Bool, HirType::String(size) => ast::Type::String(size.evaluate_to_u64().unwrap_or(0)), + HirType::FmtString(size, fields) => { + let size = size.evaluate_to_u64().unwrap_or(0); + let fields = Box::new(Self::convert_type(fields.as_ref())); + ast::Type::FmtString(size, fields) + } HirType::Unit => ast::Type::Unit, HirType::Array(length, element) => { - let length = length.evaluate_to_u64().unwrap_or(0); - let element = Self::convert_type(element.as_ref()); - ast::Type::Array(length, Box::new(element)) - } + let element = Box::new(Self::convert_type(element.as_ref())); - HirType::Slice(element) => { - let element = Self::convert_type(element.as_ref()); - ast::Type::Slice(Box::new(element)) + if let Some(length) = length.evaluate_to_u64() { + ast::Type::Array(length, element) + } else { + ast::Type::Slice(element) + } } - HirType::TypeVariable(binding, _) | HirType::NamedGeneric(binding, _) => { + HirType::NamedGeneric(binding, _) => { if let TypeBinding::Bound(binding) = &*binding.borrow() { return Self::convert_type(binding); } - // Default any remaining unbound type variables to Field. + // Default any remaining unbound type variables. // This should only happen if the variable in question is unused // and within a larger generic type. // NOTE: Make sure to review this if there is ever type-directed dispatch, // like automatic solving of traits. It should be fine since it is strictly // after type checking, but care should be taken that it doesn't change which // impls are chosen. - *binding.borrow_mut() = - TypeBinding::Bound(HirType::FieldElement(CompTime::No(None))); + *binding.borrow_mut() = TypeBinding::Bound(HirType::field(None)); ast::Type::Field } + HirType::TypeVariable(binding, kind) => { + if let TypeBinding::Bound(binding) = &*binding.borrow() { + return Self::convert_type(binding); + } + + // Default any remaining unbound type variables. + // This should only happen if the variable in question is unused + // and within a larger generic type. + // NOTE: Make sure to review this if there is ever type-directed dispatch, + // like automatic solving of traits. It should be fine since it is strictly + // after type checking, but care should be taken that it doesn't change which + // impls are chosen. + let default = kind.default_type(); + let monomorphized_default = Self::convert_type(&default); + *binding.borrow_mut() = TypeBinding::Bound(default); + monomorphized_default + } + HirType::Struct(def, args) => { let fields = def.borrow().get_fields(args); let fields = vecmap(fields, |(_, field)| Self::convert_type(&field)); @@ -628,10 +686,11 @@ impl<'interner> Monomorphizer<'interner> { ast::Type::Tuple(fields) } - HirType::Function(args, ret) => { + HirType::Function(args, ret, env) => { let args = vecmap(args, Self::convert_type); let ret = Box::new(Self::convert_type(ret)); - ast::Type::Function(args, ret) + let env = Box::new(Self::convert_type(env)); + ast::Type::Function(args, ret, env) } HirType::MutableReference(element) => { @@ -639,25 +698,53 @@ impl<'interner> Monomorphizer<'interner> { ast::Type::MutableReference(Box::new(element)) } - HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => { + HirType::Forall(_, _) + | HirType::Constant(_) + | HirType::NotConstant + | HirType::Error => { unreachable!("Unexpected type {} found", typ) } } } + fn is_function_closure(&self, raw_func_id: node_interner::ExprId) -> bool { + let t = Self::convert_type(&self.interner.id_type(raw_func_id)); + if self.is_function_closure_type(&t) { + true + } else if let ast::Type::Tuple(elements) = t { + if elements.len() == 2 { + matches!(elements[1], ast::Type::Function(_, _, _)) + } else { + false + } + } else { + false + } + } + + fn is_function_closure_type(&self, t: &ast::Type) -> bool { + if let ast::Type::Function(_, _, env) = t { + let e = (*env).clone(); + matches!(*e, ast::Type::Tuple(_captures)) + } else { + false + } + } + fn function_call( &mut self, call: HirCallExpression, id: node_interner::ExprId, ) -> ast::Expression { - let func = Box::new(self.expr(call.func)); + let original_func = Box::new(self.expr(call.func)); let mut arguments = vecmap(&call.arguments, |id| self.expr(*id)); let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id)); + let func: Box; let return_type = self.interner.id_type(id); let return_type = Self::convert_type(&return_type); let location = call.location; - if let ast::Expression::Ident(ident) = func.as_ref() { + if let ast::Expression::Ident(ident) = original_func.as_ref() { if let Definition::Oracle(name) = &ident.definition { if name.as_str() == "println" { // Oracle calls are required to be wrapped in an unconstrained function @@ -667,8 +754,39 @@ impl<'interner> Monomorphizer<'interner> { } } - self.try_evaluate_call(&func, &call.arguments, &return_type) - .unwrap_or(ast::Expression::Call(ast::Call { func, arguments, return_type, location })) + let mut block_expressions = vec![]; + + let is_closure = self.is_function_closure(call.func); + if is_closure { + let extracted_func: ast::Expression; + let hir_call_func = self.interner.expression(&call.func); + if let HirExpression::Lambda(l) = hir_call_func { + let (setup, closure_variable) = self.lambda_with_setup(l, call.func); + block_expressions.push(setup); + extracted_func = closure_variable; + } else { + extracted_func = *original_func; + } + func = Box::new(ast::Expression::ExtractTupleField( + Box::new(extracted_func.clone()), + 1usize, + )); + let env_argument = ast::Expression::ExtractTupleField(Box::new(extracted_func), 0usize); + arguments.insert(0, env_argument); + } else { + func = original_func.clone(); + }; + + let call = self + .try_evaluate_call(&func, &return_type) + .unwrap_or(ast::Expression::Call(ast::Call { func, arguments, return_type, location })); + + if !block_expressions.is_empty() { + block_expressions.push(call); + ast::Expression::Block(block_expressions) + } else { + call + } } /// Adds a function argument that contains type metadata that is required to tell @@ -681,23 +799,57 @@ impl<'interner> Monomorphizer<'interner> { /// of field elements to/from JSON. The type metadata attached in this method /// is the serialized `AbiType` for the argument passed to the function. /// The caller that is running a Noir program should then deserialize the `AbiType`, - /// and accurately decode the list of field elements passed to the foreign call. - fn append_abi_arg(&self, hir_argument: &HirExpression, arguments: &mut Vec) { + /// and accurately decode the list of field elements passed to the foreign call. + fn append_abi_arg( + &mut self, + hir_argument: &HirExpression, + arguments: &mut Vec, + ) { match hir_argument { HirExpression::Ident(ident) => { let typ = self.interner.id_type(ident.id); - let typ = typ.follow_bindings(); - - let abi_type = typ.as_abi_type(); - let abi_as_string = - serde_json::to_string(&abi_type).expect("ICE: expected Abi type to serialize"); - - arguments.push(ast::Expression::Literal(ast::Literal::Str(abi_as_string))); + let typ: Type = typ.follow_bindings(); + let is_fmt_str = match typ { + // A format string has many different possible types that need to be handled. + // Loop over each element in the format string to fetch each type's relevant metadata + Type::FmtString(_, elements) => { + match *elements { + Type::Tuple(element_types) => { + for typ in element_types { + Self::append_abi_arg_inner(&typ, arguments); + } + } + _ => unreachable!( + "ICE: format string type should be a tuple but got a {elements}" + ), + } + true + } + _ => { + Self::append_abi_arg_inner(&typ, arguments); + false + } + }; + // The caller needs information as to whether it is handling a format string or a single type + arguments.push(ast::Expression::Literal(ast::Literal::Bool(is_fmt_str))); } _ => unreachable!("logging expr {:?} is not supported", arguments[0]), } } + fn append_abi_arg_inner(typ: &Type, arguments: &mut Vec) { + if let HirType::Array(size, _) = typ { + if let HirType::NotConstant = **size { + unreachable!("println does not support slices. Convert the slice to an array before passing it to println"); + } + } + let abi_type = typ.as_abi_type(); + let abi_as_string = + serde_json::to_string(&abi_type).expect("ICE: expected Abi type to serialize"); + + arguments.push(ast::Expression::Literal(ast::Literal::Str(abi_as_string))); + } + /// Try to evaluate certain builtin functions (currently only 'array_len' and field modulus methods) /// at their call site. /// NOTE: Evaluating at the call site means we cannot track aliased functions. @@ -707,25 +859,12 @@ impl<'interner> Monomorphizer<'interner> { fn try_evaluate_call( &mut self, func: &ast::Expression, - arguments: &[node_interner::ExprId], result_type: &ast::Type, ) -> Option { if let ast::Expression::Ident(ident) = func { if let Definition::Builtin(opcode) = &ident.definition { // TODO(#1736): Move this builtin to the SSA pass return match opcode.as_str() { - "array_len" => { - let typ = self.interner.id_type(arguments[0]); - if let Type::Array(_, _) = typ { - let len = typ.evaluate_to_u64().unwrap(); - Some(ast::Expression::Literal(ast::Literal::Integer( - (len as u128).into(), - ast::Type::Field, - ))) - } else { - None - } - } "modulus_num_bits" => Some(ast::Expression::Literal(ast::Literal::Integer( (FieldElement::max_num_bits() as u128).into(), ast::Type::Field, @@ -755,17 +894,17 @@ impl<'interner> Monomorphizer<'interner> { } fn modulus_array_literal(&self, bytes: Vec, arr_elem_bits: u32) -> ast::Expression { + use ast::*; + let int_type = Type::Integer(crate::Signedness::Unsigned, arr_elem_bits); + let bytes_as_expr = vecmap(bytes, |byte| { - ast::Expression::Literal(ast::Literal::Integer( - (byte as u128).into(), - ast::Type::Integer(crate::Signedness::Unsigned, arr_elem_bits), - )) + Expression::Literal(Literal::Integer((byte as u128).into(), int_type.clone())) }); - let arr_literal = ast::ArrayLiteral { - contents: bytes_as_expr, - element_type: ast::Type::Integer(crate::Signedness::Unsigned, arr_elem_bits), - }; - ast::Expression::Literal(ast::Literal::Array(arr_literal)) + + let typ = Type::Array(bytes_as_expr.len() as u64, Box::new(int_type)); + + let arr_literal = ArrayLiteral { typ, contents: bytes_as_expr }; + Expression::Literal(Literal::Array(arr_literal)) } fn queue_function( @@ -857,7 +996,16 @@ impl<'interner> Monomorphizer<'interner> { } } - fn lambda(&mut self, lambda: HirLambda) -> ast::Expression { + fn lambda(&mut self, lambda: HirLambda, expr: node_interner::ExprId) -> ast::Expression { + if lambda.captures.is_empty() { + self.lambda_no_capture(lambda) + } else { + let (setup, closure_variable) = self.lambda_with_setup(lambda, expr); + ast::Expression::Block(vec![setup, closure_variable]) + } + } + + fn lambda_no_capture(&mut self, lambda: HirLambda) -> ast::Expression { let ret_type = Self::convert_type(&lambda.return_type); let lambda_name = "lambda"; let parameter_types = vecmap(&lambda.parameters, |(_, typ)| Self::convert_type(typ)); @@ -878,7 +1026,8 @@ impl<'interner> Monomorphizer<'interner> { let function = ast::Function { id, name, parameters, body, return_type, unconstrained }; self.push_function(id, function); - let typ = ast::Type::Function(parameter_types, Box::new(ret_type)); + let typ = + ast::Type::Function(parameter_types, Box::new(ret_type), Box::new(ast::Type::Unit)); let name = lambda_name.to_owned(); ast::Expression::Ident(ast::Ident { @@ -890,6 +1039,133 @@ impl<'interner> Monomorphizer<'interner> { }) } + fn lambda_with_setup( + &mut self, + lambda: HirLambda, + expr: node_interner::ExprId, + ) -> (ast::Expression, ast::Expression) { + // returns (, ) + // which can be used directly in callsites or transformed + // directly to a single `Expression` + // for other cases by `lambda` which is called by `expr` + // + // it solves the problem of detecting special cases where + // we call something like + // `{let env$.. = ..;}.1({let env$.. = ..;}.0, ..)` + // which was leading to redefinition errors + // + // instead of detecting and extracting + // patterns in the resulting tree, + // which seems more fragile, we directly reuse the return parameters + // of this function in those cases + let ret_type = Self::convert_type(&lambda.return_type); + let lambda_name = "lambda"; + let parameter_types = vecmap(&lambda.parameters, |(_, typ)| Self::convert_type(typ)); + + // Manually convert to Parameters type so we can reuse the self.parameters method + let parameters = Parameters(vecmap(lambda.parameters, |(pattern, typ)| { + Param(pattern, typ, noirc_abi::AbiVisibility::Private) + })); + + let mut converted_parameters = self.parameters(parameters); + + let id = self.next_function_id(); + let name = lambda_name.to_owned(); + let return_type = ret_type.clone(); + + let env_local_id = self.next_local_id(); + let env_name = "env"; + let env_tuple = ast::Expression::Tuple(vecmap(&lambda.captures, |capture| { + match capture.transitive_capture_index { + Some(field_index) => match self.lambda_envs_stack.last() { + Some(lambda_ctx) => ast::Expression::ExtractTupleField( + lambda_ctx.env_ident.clone(), + field_index, + ), + None => unreachable!( + "Expected to find a parent closure environment, but found none" + ), + }, + None => { + let ident = self.local_ident(&capture.ident).unwrap(); + ast::Expression::Ident(ident) + } + } + })); + let expr_type = self.interner.id_type(expr); + let env_typ = if let types::Type::Function(_, _, function_env_type) = expr_type { + Self::convert_type(&function_env_type) + } else { + unreachable!("expected a Function type for a Lambda node") + }; + + let env_let_stmt = ast::Expression::Let(ast::Let { + id: env_local_id, + mutable: false, + name: env_name.to_string(), + expression: Box::new(env_tuple), + }); + + let location = None; // TODO: This should match the location of the lambda expression + let mutable = false; + let definition = Definition::Local(env_local_id); + + let env_ident = ast::Expression::Ident(ast::Ident { + location, + mutable, + definition, + name: env_name.to_string(), + typ: env_typ.clone(), + }); + + self.lambda_envs_stack.push(LambdaContext { + env_ident: Box::new(env_ident.clone()), + captures: lambda.captures, + }); + let body = self.expr(lambda.body); + self.lambda_envs_stack.pop(); + + let lambda_fn_typ: ast::Type = + ast::Type::Function(parameter_types, Box::new(ret_type), Box::new(env_typ.clone())); + let lambda_fn = ast::Expression::Ident(ast::Ident { + definition: Definition::Function(id), + mutable: false, + location: None, // TODO: This should match the location of the lambda expression + name: name.clone(), + typ: lambda_fn_typ.clone(), + }); + + let mut parameters = vec![]; + parameters.push((env_local_id, true, env_name.to_string(), env_typ.clone())); + parameters.append(&mut converted_parameters); + + let unconstrained = false; + let function = ast::Function { id, name, parameters, body, return_type, unconstrained }; + self.push_function(id, function); + + let lambda_value = ast::Expression::Tuple(vec![env_ident, lambda_fn]); + let block_local_id = self.next_local_id(); + let block_ident_name = "closure_variable"; + let block_let_stmt = ast::Expression::Let(ast::Let { + id: block_local_id, + mutable: false, + name: block_ident_name.to_string(), + expression: Box::new(ast::Expression::Block(vec![env_let_stmt, lambda_value])), + }); + + let closure_definition = Definition::Local(block_local_id); + + let closure_ident = ast::Expression::Ident(ast::Ident { + location, + mutable: false, + definition: closure_definition, + name: block_ident_name.to_string(), + typ: ast::Type::Tuple(vec![env_typ, lambda_fn_typ]), + }); + + (block_let_stmt, closure_ident) + } + /// Implements std::unsafe::zeroed by returning an appropriate zeroed /// ast literal or collection node for the given type. Note that for functions /// there is no obvious zeroed value so this should be considered unsafe to use. @@ -906,22 +1182,34 @@ impl<'interner> Monomorphizer<'interner> { let element = self.zeroed_value_of_type(element_type.as_ref()); ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents: vec![element; *length as usize], - element_type: element_type.as_ref().clone(), + typ: ast::Type::Array(*length, element_type.clone()), })) } ast::Type::String(length) => { ast::Expression::Literal(ast::Literal::Str("\0".repeat(*length as usize))) } + ast::Type::FmtString(length, fields) => { + let zeroed_tuple = self.zeroed_value_of_type(fields); + let fields_len = match &zeroed_tuple { + ast::Expression::Tuple(fields) => fields.len() as u64, + _ => unreachable!("ICE: format string fields should be structured in a tuple, but got a {zeroed_tuple}"), + }; + ast::Expression::Literal(ast::Literal::FmtStr( + "\0".repeat(*length as usize), + fields_len, + Box::new(zeroed_tuple), + )) + } ast::Type::Tuple(fields) => { ast::Expression::Tuple(vecmap(fields, |field| self.zeroed_value_of_type(field))) } - ast::Type::Function(parameter_types, ret_type) => { - self.create_zeroed_function(parameter_types, ret_type) + ast::Type::Function(parameter_types, ret_type, env) => { + self.create_zeroed_function(parameter_types, ret_type, env) } ast::Type::Slice(element_type) => { ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents: vec![], - element_type: *element_type.clone(), + typ: ast::Type::Slice(element_type.clone()), })) } ast::Type::MutableReference(element) => { @@ -943,6 +1231,7 @@ impl<'interner> Monomorphizer<'interner> { &mut self, parameter_types: &[ast::Type], ret_type: &ast::Type, + env_type: &ast::Type, ) -> ast::Expression { let lambda_name = "zeroed_lambda"; @@ -965,7 +1254,11 @@ impl<'interner> Monomorphizer<'interner> { mutable: false, location: None, name: lambda_name.to_owned(), - typ: ast::Type::Function(parameter_types.to_owned(), Box::new(ret_type.clone())), + typ: ast::Type::Function( + parameter_types.to_owned(), + Box::new(ret_type.clone()), + Box::new(env_type.clone()), + ), }) } } @@ -992,20 +1285,6 @@ fn unwrap_struct_type(typ: &HirType) -> Vec<(String, HirType)> { } } -fn unwrap_array_element_type(typ: &HirType) -> HirType { - match typ { - HirType::Array(_, elem) => *elem.clone(), - HirType::Slice(elem) => *elem.clone(), - HirType::TypeVariable(binding, TypeVariableKind::Normal) => match &*binding.borrow() { - TypeBinding::Bound(binding) => unwrap_array_element_type(binding), - TypeBinding::Unbound(_) => unreachable!(), - }, - other => { - unreachable!("unwrap_array_element_type: expected an array or slice, found {:?}", other) - } - } -} - fn perform_instantiation_bindings(bindings: &TypeBindings) { for (var, binding) in bindings.values() { *var.borrow_mut() = TypeBinding::Bound(binding.clone()); @@ -1017,3 +1296,167 @@ fn undo_instantiation_bindings(bindings: TypeBindings) { *var.borrow_mut() = TypeBinding::Unbound(id); } } + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + + use fm::FileId; + use iter_extended::vecmap; + + use crate::{ + graph::CrateId, + hir::{ + def_map::{ + CrateDefMap, LocalModuleId, ModuleData, ModuleDefId, ModuleId, ModuleOrigin, + }, + resolution::{ + import::PathResolutionError, path_resolver::PathResolver, resolver::Resolver, + }, + }, + hir_def::function::HirFunction, + node_interner::{FuncId, NodeInterner}, + parse_program, + }; + + use super::monomorphize; + + // TODO: refactor into a more general test utility? + // mostly copied from hir / type_check / mod.rs and adapted a bit + fn type_check_src_code(src: &str, func_namespace: Vec) -> (FuncId, NodeInterner) { + let (program, errors) = parse_program(src); + let mut interner = NodeInterner::default(); + + // Using assert_eq here instead of assert(errors.is_empty()) displays + // the whole vec if the assert fails rather than just two booleans + assert_eq!(errors, vec![]); + + let main_id = interner.push_fn(HirFunction::empty()); + interner.push_function_definition("main".into(), main_id); + + let func_ids = vecmap(&func_namespace, |name| { + let id = interner.push_fn(HirFunction::empty()); + interner.push_function_definition(name.into(), id); + id + }); + + let mut path_resolver = TestPathResolver(HashMap::new()); + for (name, id) in func_namespace.into_iter().zip(func_ids.clone()) { + path_resolver.insert_func(name.to_owned(), id); + } + + let mut def_maps: HashMap = HashMap::new(); + let file = FileId::default(); + + let mut modules = arena::Arena::new(); + modules.insert(ModuleData::new(None, ModuleOrigin::File(file), false)); + + def_maps.insert( + CrateId::dummy_id(), + CrateDefMap { + root: path_resolver.local_module_id(), + modules, + krate: CrateId::dummy_id(), + extern_prelude: HashMap::new(), + }, + ); + + let func_meta = vecmap(program.functions, |nf| { + let resolver = Resolver::new(&mut interner, &path_resolver, &def_maps, file); + let (hir_func, func_meta, _resolver_errors) = + resolver.resolve_function(nf, main_id, ModuleId::dummy_id()); + // TODO: not sure why, we do get an error here, + // but otherwise seem to get an ok monomorphization result + // assert_eq!(resolver_errors, vec![]); + (hir_func, func_meta) + }); + + println!("Before update_fn"); + + for ((hir_func, meta), func_id) in func_meta.into_iter().zip(func_ids.clone()) { + interner.update_fn(func_id, hir_func); + interner.push_fn_meta(meta, func_id); + } + + println!("Before type_check_func"); + + // Type check section + let errors = crate::hir::type_check::type_check_func( + &mut interner, + func_ids.first().cloned().unwrap(), + ); + assert_eq!(errors, vec![]); + (func_ids.first().cloned().unwrap(), interner) + } + + // TODO: refactor into a more general test utility? + // TestPathResolver struct and impls copied from hir / type_check / mod.rs + struct TestPathResolver(HashMap); + + impl PathResolver for TestPathResolver { + fn resolve( + &self, + _def_maps: &HashMap, + path: crate::Path, + ) -> Result { + // Not here that foo::bar and hello::foo::bar would fetch the same thing + let name = path.segments.last().unwrap(); + let mod_def = self.0.get(&name.0.contents).cloned(); + mod_def.ok_or_else(move || PathResolutionError::Unresolved(name.clone())) + } + + fn local_module_id(&self) -> LocalModuleId { + // This is not LocalModuleId::dummy since we need to use this to index into a Vec + // later and do not want to push u32::MAX number of elements before we do. + LocalModuleId(arena::Index::from_raw_parts(0, 0)) + } + + fn module_id(&self) -> ModuleId { + ModuleId { krate: CrateId::dummy_id(), local_id: self.local_module_id() } + } + } + + impl TestPathResolver { + fn insert_func(&mut self, name: String, func_id: FuncId) { + self.0.insert(name, func_id.into()); + } + } + + // a helper test method + // TODO: maybe just compare trimmed src/expected + // for easier formatting? + fn check_rewrite(src: &str, expected: &str) { + let (func, interner) = type_check_src_code(src, vec!["main".to_string()]); + let program = monomorphize(func, &interner); + // println!("[{}]", program); + assert!(format!("{}", program) == expected); + } + + #[test] + fn simple_closure_with_no_captured_variables() { + let src = r#" + fn main() -> Field { + let x = 1; + let closure = || x; + closure() + } + "#; + + let expected_rewrite = r#"fn main$f0() -> Field { + let x$0 = 1; + let closure$3 = { + let closure_variable$2 = { + let env$1 = (x$l0); + (env$l1, lambda$f1) + }; + closure_variable$l2 + }; + closure$l3.1(closure$l3.0) +} +fn lambda$f1(mut env$l1: (Field)) -> Field { + env$l1.0 +} +"#; + check_rewrite(src, expected_rewrite); + } +} diff --git a/crates/noirc_frontend/src/monomorphization/printer.rs b/crates/noirc_frontend/src/monomorphization/printer.rs index 929a14e07da..ff2b7d0d256 100644 --- a/crates/noirc_frontend/src/monomorphization/printer.rs +++ b/crates/noirc_frontend/src/monomorphization/printer.rs @@ -96,6 +96,11 @@ impl AstPrinter { super::ast::Literal::Integer(x, _) => x.fmt(f), super::ast::Literal::Bool(x) => x.fmt(f), super::ast::Literal::Str(s) => s.fmt(f), + super::ast::Literal::FmtStr(s, _, _) => { + write!(f, "f\"")?; + s.fmt(f)?; + write!(f, "\"") + } } } diff --git a/crates/noirc_frontend/src/node_interner.rs b/crates/noirc_frontend/src/node_interner.rs index fa2ce49ed11..6b3d2757c14 100644 --- a/crates/noirc_frontend/src/node_interner.rs +++ b/crates/noirc_frontend/src/node_interner.rs @@ -7,7 +7,7 @@ use noirc_errors::{Location, Span, Spanned}; use crate::ast::Ident; use crate::graph::CrateId; -use crate::hir::def_collector::dc_crate::UnresolvedStruct; +use crate::hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTypeAlias}; use crate::hir::def_map::{LocalModuleId, ModuleId}; use crate::hir::StorageSlot; use crate::hir_def::stmt::HirLetStatement; @@ -17,7 +17,10 @@ use crate::hir_def::{ function::{FuncMeta, HirFunction}, stmt::HirStatement, }; -use crate::{Shared, TypeBinding, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind}; +use crate::{ + Generics, Shared, TypeAliasType, TypeBinding, TypeBindings, TypeVariable, TypeVariableId, + TypeVariableKind, +}; /// The node interner is the central storage location of all nodes in Noir's Hir (the /// various node types can be found in hir_def). The interner is also used to collect @@ -52,6 +55,12 @@ pub struct NodeInterner { // methods from impls to the type. structs: HashMap>, + // Type Aliases map. + // + // Map type aliases to the actual type. + // When resolving types, check against this map to see if a type alias is defined. + type_aliases: Vec, + /// Map from ExprId (referring to a Function/Method call) to its corresponding TypeBindings, /// filled out during type checking from instantiated variables. Used during monomorphization /// to map call site types back onto function parameter types, and undo this binding as needed. @@ -132,6 +141,15 @@ impl StructId { } } +#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)] +pub struct TypeAliasId(pub usize); + +impl TypeAliasId { + pub fn dummy_id() -> TypeAliasId { + TypeAliasId(std::usize::MAX) + } +} + macro_rules! into_index { ($id_type:ty) => { impl From<$id_type> for Index { @@ -213,11 +231,11 @@ impl DefinitionKind { matches!(self, DefinitionKind::Global(..)) } - pub fn get_rhs(self) -> Option { + pub fn get_rhs(&self) -> Option { match self { DefinitionKind::Function(_) => None, - DefinitionKind::Global(id) => Some(id), - DefinitionKind::Local(id) => id, + DefinitionKind::Global(id) => Some(*id), + DefinitionKind::Local(id) => *id, DefinitionKind::GenericType(_) => None, } } @@ -243,6 +261,7 @@ impl Default for NodeInterner { definitions: vec![], id_to_type: HashMap::new(), structs: HashMap::new(), + type_aliases: Vec::new(), instantiation_bindings: HashMap::new(), field_indices: HashMap::new(), next_type_variable_id: 0, @@ -305,11 +324,33 @@ impl NodeInterner { ); } + pub fn push_type_alias(&mut self, typ: &UnresolvedTypeAlias) -> TypeAliasId { + let type_id = TypeAliasId(self.type_aliases.len()); + + self.type_aliases.push(TypeAliasType::new( + type_id, + typ.type_alias_def.name.clone(), + typ.type_alias_def.span, + Type::Error, + vecmap(&typ.type_alias_def.generics, |_| { + let id = TypeVariableId(0); + (id, Shared::new(TypeBinding::Unbound(id))) + }), + )); + + type_id + } + pub fn update_struct(&mut self, type_id: StructId, f: impl FnOnce(&mut StructType)) { let mut value = self.structs.get_mut(&type_id).unwrap().borrow_mut(); f(&mut value); } + pub fn set_type_alias(&mut self, type_id: TypeAliasId, typ: Type, generics: Generics) { + let type_alias_type = &mut self.type_aliases[type_id.0]; + type_alias_type.set_type_and_generics(typ, generics); + } + /// Returns the interned statement corresponding to `stmt_id` pub fn update_statement(&mut self, stmt_id: &StmtId, f: impl FnOnce(&mut HirStatement)) { let def = @@ -506,6 +547,10 @@ impl NodeInterner { self.structs[&id].clone() } + pub fn get_type_alias(&self, id: TypeAliasId) -> &TypeAliasType { + &self.type_aliases[id.0] + } + pub fn get_global(&self, stmt_id: &StmtId) -> Option { self.globals.get(stmt_id).cloned() } @@ -608,7 +653,6 @@ enum TypeMethodKey { /// accept only fields or integers, it is just that their names may not clash. FieldOrInt, Array, - Slice, Bool, String, Unit, @@ -622,14 +666,13 @@ fn get_type_method_key(typ: &Type) -> Option { match &typ { Type::FieldElement(_) => Some(FieldOrInt), Type::Array(_, _) => Some(Array), - Type::Slice(_) => Some(Slice), Type::Integer(_, _, _) => Some(FieldOrInt), Type::TypeVariable(_, TypeVariableKind::IntegerOrField(_)) => Some(FieldOrInt), Type::Bool(_) => Some(Bool), Type::String(_) => Some(String), Type::Unit => Some(Unit), Type::Tuple(_) => Some(Tuple), - Type::Function(_, _) => Some(Function), + Type::Function(_, _, _) => Some(Function), Type::MutableReference(element) => get_type_method_key(element), // We do not support adding methods to these types @@ -638,6 +681,8 @@ fn get_type_method_key(typ: &Type) -> Option { | Type::Forall(_, _) | Type::Constant(_) | Type::Error - | Type::Struct(_, _) => None, + | Type::NotConstant + | Type::Struct(_, _) + | Type::FmtString(_, _) => None, } } diff --git a/crates/noirc_frontend/src/parser/mod.rs b/crates/noirc_frontend/src/parser/mod.rs index 9cf9f1e9869..ad519836b39 100644 --- a/crates/noirc_frontend/src/parser/mod.rs +++ b/crates/noirc_frontend/src/parser/mod.rs @@ -17,8 +17,8 @@ use crate::token::{Keyword, Token}; use crate::{ast::ImportStatement, Expression, NoirStruct}; use crate::{ BlockExpression, ExpressionKind, ForExpression, Ident, IndexExpression, LetStatement, - MethodCallExpression, NoirFunction, NoirTrait, Path, PathKind, Pattern, Recoverable, Statement, - TraitImpl, TypeImpl, UnresolvedType, UseTree, + MethodCallExpression, NoirFunction, NoirTrait, NoirTypeAlias, Path, PathKind, Pattern, + Recoverable, Statement, TraitImpl, TypeImpl, UnresolvedType, UseTree, }; use acvm::FieldElement; @@ -43,6 +43,7 @@ pub(crate) enum TopLevelStatement { Trait(NoirTrait), TraitImpl(TraitImpl), Impl(TypeImpl), + TypeAlias(NoirTypeAlias), SubModule(SubModule), Global(LetStatement), Error, @@ -225,6 +226,7 @@ pub struct ParsedModule { pub traits: Vec, pub trait_impls: Vec, pub impls: Vec, + pub type_aliases: Vec, pub globals: Vec, /// Module declarations like `mod foo;` @@ -264,6 +266,10 @@ impl ParsedModule { self.impls.push(r#impl); } + fn push_type_alias(&mut self, type_alias: NoirTypeAlias) { + self.type_aliases.push(type_alias); + } + fn push_import(&mut self, import_stmt: UseTree) { self.imports.extend(import_stmt.desugar(None)); } @@ -463,6 +469,7 @@ impl std::fmt::Display for TopLevelStatement { TopLevelStatement::TraitImpl(i) => i.fmt(f), TopLevelStatement::Struct(s) => s.fmt(f), TopLevelStatement::Impl(i) => i.fmt(f), + TopLevelStatement::TypeAlias(t) => t.fmt(f), TopLevelStatement::SubModule(s) => s.fmt(f), TopLevelStatement::Global(c) => c.fmt(f), TopLevelStatement::Error => write!(f, "error"), @@ -496,6 +503,10 @@ impl std::fmt::Display for ParsedModule { write!(f, "{impl_}")?; } + for type_alias in &self.type_aliases { + write!(f, "{type_alias}")?; + } + for submodule in &self.submodules { write!(f, "{submodule}")?; } diff --git a/crates/noirc_frontend/src/parser/parser.rs b/crates/noirc_frontend/src/parser/parser.rs index c8142ffa947..6445205eae6 100644 --- a/crates/noirc_frontend/src/parser/parser.rs +++ b/crates/noirc_frontend/src/parser/parser.rs @@ -36,8 +36,8 @@ use crate::token::{Attribute, Keyword, Token, TokenKind}; use crate::{ BinaryOp, BinaryOpKind, BlockExpression, CompTime, ConstrainStatement, FunctionDefinition, Ident, IfExpression, InfixExpression, LValue, Lambda, Literal, NoirFunction, NoirStruct, - NoirTrait, Path, PathKind, Pattern, Recoverable, TraitConstraint, TraitImpl, TraitImplItem, - TraitItem, TypeImpl, UnaryOp, UnresolvedTypeExpression, UseTree, UseTreeKind, + NoirTrait, NoirTypeAlias, Path, PathKind, Pattern, Recoverable, TraitConstraint, TraitImpl, + TraitImplItem, TraitItem, TypeImpl, UnaryOp, UnresolvedTypeExpression, UseTree, UseTreeKind, }; use chumsky::prelude::*; @@ -82,6 +82,7 @@ fn module() -> impl NoirParser { TopLevelStatement::Trait(t) => program.push_trait(t), TopLevelStatement::TraitImpl(t) => program.push_trait_impl(t), TopLevelStatement::Impl(i) => program.push_impl(i), + TopLevelStatement::TypeAlias(t) => program.push_type_alias(t), TopLevelStatement::SubModule(s) => program.push_submodule(s), TopLevelStatement::Global(c) => program.push_global(c), TopLevelStatement::Error => (), @@ -108,6 +109,7 @@ fn top_level_statement( trait_definition(), trait_implementation(), implementation(), + type_alias_definition().then_ignore(force(just(Token::Semicolon))), submodule(module_parser.clone()), contract(module_parser), module_declaration().then_ignore(force(just(Token::Semicolon))), @@ -236,6 +238,19 @@ fn struct_definition() -> impl NoirParser { ) } +fn type_alias_definition() -> impl NoirParser { + use self::Keyword::Type; + + let p = ignore_then_commit(keyword(Type), ident()); + let p = then_commit(p, generics()); + let p = then_commit_ignore(p, just(Token::Assign)); + let p = then_commit(p, parse_type()); + + p.map_with_span(|((name, generics), typ), span| { + TopLevelStatement::TypeAlias(NoirTypeAlias { name, generics, typ, span }) + }) +} + fn lambda_return_type() -> impl NoirParser { just(Token::Arrow) .ignore_then(parse_type()) @@ -795,6 +810,7 @@ fn parse_type_inner( int_type(), bool_type(), string_type(), + format_string_type(recursive_type_parser.clone()), named_type(recursive_type_parser.clone()), array_type(recursive_type_parser.clone()), recursive_type_parser.clone().delimited_by(just(Token::LeftParen), just(Token::RightParen)), @@ -841,6 +857,19 @@ fn string_type() -> impl NoirParser { .map(UnresolvedType::String) } +fn format_string_type( + type_parser: impl NoirParser, +) -> impl NoirParser { + keyword(Keyword::FormatString) + .ignore_then( + type_expression() + .then_ignore(just(Token::Comma)) + .then(type_parser) + .delimited_by(just(Token::Less), just(Token::Greater)), + ) + .map(|(size, fields)| UnresolvedType::FormatString(size, Box::new(fields))) +} + fn int_type() -> impl NoirParser { maybe_comp_time() .then(filter_map(|span, token: Token| match token { @@ -1267,7 +1296,7 @@ where { just(Token::Star) .ignore_then(term_parser) - .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference, rhs)) + .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference { implicitly_added: false }, rhs)) } /// Atoms are parameterized on whether constructor expressions are allowed or not. @@ -1366,6 +1395,7 @@ fn literal() -> impl NoirParser { Token::Int(x) => ExpressionKind::integer(x), Token::Bool(b) => ExpressionKind::boolean(b), Token::Str(s) => ExpressionKind::string(s), + Token::FmtStr(s) => ExpressionKind::format_string(s), unexpected => unreachable!("Non-literal {} parsed as a literal", unexpected), }) } @@ -1902,6 +1932,15 @@ mod test { parse_all_failing(struct_definition(), failing); } + #[test] + fn parse_type_aliases() { + let cases = vec!["type foo = u8", "type bar = String", "type baz = Vec"]; + parse_all(type_alias_definition(), cases); + + let failing = vec!["type = u8", "type foo", "type foo = 1"]; + parse_all_failing(type_alias_definition(), failing); + } + #[test] fn parse_member_access() { let cases = vec!["a.b", "a + b.c", "foo.bar as i32"]; diff --git a/crates/wasm/package.json b/crates/wasm/package.json index a09d0885a21..4aa881ddea6 100644 --- a/crates/wasm/package.json +++ b/crates/wasm/package.json @@ -14,7 +14,7 @@ "module": "./web/noir_wasm.js", "sideEffects": false, "peerDependencies": { - "@noir-lang/noir-source-resolver": "1.1.2" + "@noir-lang/noir-source-resolver": "1.1.3" }, "repository": { "type": "git", diff --git a/crates/wasm/src/compile.rs b/crates/wasm/src/compile.rs index c940f0ce246..4254110b849 100644 --- a/crates/wasm/src/compile.rs +++ b/crates/wasm/src/compile.rs @@ -3,8 +3,8 @@ use fm::FileManager; use gloo_utils::format::JsValueSerdeExt; use log::debug; use noirc_driver::{ - check_crate, compile_contracts, compile_no_check, create_local_crate, create_non_local_crate, - propagate_dep, CompileOptions, CompiledContract, + check_crate, compile_contracts, compile_no_check, prepare_crate, propagate_dep, CompileOptions, + CompiledContract, }; use noirc_frontend::{ graph::{CrateGraph, CrateType}, @@ -63,7 +63,7 @@ impl Default for WASMCompileOptions { fn add_noir_lib(context: &mut Context, crate_name: &str) { let path_to_lib = Path::new(&crate_name).join("lib.nr"); - let library_crate = create_non_local_crate(context, &path_to_lib, CrateType::Library); + let library_crate = prepare_crate(context, &path_to_lib, CrateType::Library); propagate_dep(context, library_crate, &crate_name.parse().unwrap()); } @@ -87,7 +87,7 @@ pub fn compile(args: JsValue) -> JsValue { let mut context = Context::new(fm, graph); let path = Path::new(&options.entry_point); - let crate_id = create_local_crate(&mut context, path, CrateType::Binary); + let crate_id = prepare_crate(&mut context, path, CrateType::Binary); for dependency in options.optional_dependencies_set { add_noir_lib(&mut context, dependency.as_str()); @@ -107,8 +107,8 @@ pub fn compile(args: JsValue) -> JsValue { ::from_serde(&optimized_contracts).unwrap() } else { let main = context.get_main_function(&crate_id).expect("Could not find main function!"); - let mut compiled_program = compile_no_check(&context, true, &options.compile_options, main) - .expect("Compilation failed"); + let mut compiled_program = + compile_no_check(&context, &options.compile_options, main).expect("Compilation failed"); compiled_program.circuit = optimize_circuit(compiled_program.circuit); diff --git a/cspell.json b/cspell.json index 64413c3faf3..8da1d65fb56 100644 --- a/cspell.json +++ b/cspell.json @@ -63,6 +63,7 @@ "typevars", "udiv", "uninstantiated", + "unnormalized", "urem", "vecmap", "direnv", @@ -99,4 +100,4 @@ "termcolor", "thiserror" ] -} \ No newline at end of file +} diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr index 9e44aa03fcc..db349317f91 100644 --- a/noir_stdlib/src/array.nr +++ b/noir_stdlib/src/array.nr @@ -22,6 +22,15 @@ impl [T; N] { a } + // Converts an array into a slice. + fn as_slice(self) -> [T] { + let mut slice = []; + for elem in self { + slice = slice.push_back(elem); + } + slice + } + // Apply a function to each element of an array, returning a new array // containing the mapped elements. fn map(self, f: fn(T) -> U) -> [U; N] { diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr index efeceef5df2..c46380e1988 100644 --- a/noir_stdlib/src/ecdsa_secp256k1.nr +++ b/noir_stdlib/src/ecdsa_secp256k1.nr @@ -1,2 +1,2 @@ #[foreign(ecdsa_secp256k1)] -fn verify_signature(_public_key_x : [u8; 32], _public_key_y : [u8; 32], _signature: [u8; 64], _message_hash: [u8]) -> bool {} +fn verify_signature(_public_key_x : [u8; 32], _public_key_y : [u8; 32], _signature: [u8; 64], _message_hash: [u8; N]) -> bool {} diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr index 44df07d3590..77744384f52 100644 --- a/noir_stdlib/src/ecdsa_secp256r1.nr +++ b/noir_stdlib/src/ecdsa_secp256r1.nr @@ -1,2 +1,2 @@ #[foreign(ecdsa_secp256r1)] -fn verify_signature(_public_key_x : [u8; 32], _public_key_y : [u8; 32], _signature: [u8; 64], _message_hash: [u8]) -> bool {} +fn verify_signature(_public_key_x : [u8; 32], _public_key_y : [u8; 32], _signature: [u8; 64], _message_hash: [u8; N]) -> bool {} diff --git a/noir_stdlib/src/hash/poseidon.nr b/noir_stdlib/src/hash/poseidon.nr index 416f740bbdf..cb1e34927b4 100644 --- a/noir_stdlib/src/hash/poseidon.nr +++ b/noir_stdlib/src/hash/poseidon.nr @@ -101,7 +101,7 @@ fn check_security(rate: Field, width: Field, security: Field) -> bool { } // A*x where A is an n x n matrix in row-major order and x an n-vector -fn apply_matrix(a: [Field], x: [Field; N]) -> [Field; N] { +fn apply_matrix(a: [Field; M], x: [Field; N]) -> [Field; N] { let mut y = x; for i in 0..x.len() { diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr index f6c01ecdfaa..9c0dcc6b269 100644 --- a/noir_stdlib/src/lib.nr +++ b/noir_stdlib/src/lib.nr @@ -14,15 +14,16 @@ mod ec; mod unsafe; mod collections; mod compat; +mod option; // Oracle calls are required to be wrapped in an unconstrained function // Thus, the only argument to the `println` oracle is expected to always be an ident #[oracle(println)] -unconstrained fn println_oracle(_input: T) {} +unconstrained fn println_oracle(_input: T) {} unconstrained fn println(input: T) { println_oracle(input); } #[foreign(recursive_aggregation)] -fn verify_proof(_verification_key : [Field], _proof : [Field], _public_inputs : [Field], _key_hash : Field, _input_aggregation_object : [Field]) -> [Field] {} +fn verify_proof(_verification_key : [Field], _proof : [Field], _public_inputs : [Field], _key_hash : Field, _input_aggregation_object : [Field; N]) -> [Field; N] {} diff --git a/noir_stdlib/src/merkle.nr b/noir_stdlib/src/merkle.nr index 1f1a45ffe17..07588a52a5a 100644 --- a/noir_stdlib/src/merkle.nr +++ b/noir_stdlib/src/merkle.nr @@ -3,7 +3,7 @@ // XXX: In the future we can add an arity parameter // Returns the merkle root of the tree from the provided leaf, its hashpath, using a pedersen hash function. -fn compute_merkle_root(leaf: Field, index: Field, hash_path: [Field]) -> Field { +fn compute_merkle_root(leaf: Field, index: Field, hash_path: [Field; N]) -> Field { let n = hash_path.len(); let index_bits = index.to_le_bits(n as u32); let mut current = leaf; @@ -18,4 +18,4 @@ fn compute_merkle_root(leaf: Field, index: Field, hash_path: [Field]) -> Field { current = crate::hash::pedersen([hash_left, hash_right])[0]; }; current -} \ No newline at end of file +} diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr new file mode 100644 index 00000000000..919c40fd9e0 --- /dev/null +++ b/noir_stdlib/src/option.nr @@ -0,0 +1,164 @@ +struct Option { + _is_some: bool, + _value: T, +} + +impl Option { + /// Constructs a None value + fn none() -> Self { + Self { _is_some: false, _value: crate::unsafe::zeroed() } + } + + /// Constructs a Some wrapper around the given value + fn some(_value: T) -> Self { + Self { _is_some: true, _value } + } + + /// True if this Option is None + fn is_none(self) -> bool { + !self._is_some + } + + /// True if this Option is Some + fn is_some(self) -> bool { + self._is_some + } + + /// Asserts `self.is_some()` and returns the wrapped value. + fn unwrap(self) -> T { + assert(self._is_some); + self._value + } + + /// Returns the inner value without asserting `self.is_some()` + /// Note that if `self` is `None`, there is no guarantee what value will be returned, + /// only that it will be of type `T`. + fn unwrap_unchecked(self) -> T { + self._value + } + + /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value. + fn unwrap_or(self, default: T) -> T { + if self._is_some { + self._value + } else { + default + } + } + + /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return + /// a default value. + fn unwrap_or_else(self, default: fn() -> T) -> T { + if self._is_some { + self._value + } else { + default() + } + } + + /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`. + fn map(self, f: fn(T) -> U) -> Option { + if self._is_some { + Option::some(f(self._value)) + } else { + Option::none() + } + } + + /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value. + fn map_or(self, default: U, f: fn(T) -> U) -> U { + if self._is_some { + f(self._value) + } else { + default + } + } + + /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`. + fn map_or_else(self, default: fn() -> U, f: fn(T) -> U) -> U { + if self._is_some { + f(self._value) + } else { + default() + } + } + + /// Returns None if self is None. Otherwise, this returns `other`. + fn and(self, other: Self) -> Self { + if self.is_none() { + Option::none() + } else { + other + } + } + + /// If self is None, this returns None. Otherwise, this calls the given function + /// with the Some value contained within self, and returns the result of that call. + /// + /// In some languages this function is called `flat_map` or `bind`. + fn and_then(self, f: fn(T) -> Option) -> Option { + if self._is_some { + f(self._value) + } else { + Option::none() + } + } + + /// If self is Some, return self. Otherwise, return `other`. + fn or(self, other: Self) -> Self { + if self._is_some { + self + } else { + other + } + } + + /// If self is Some, return self. Otherwise, return `default()`. + fn or_else(self, default: fn() -> Self) -> Self { + if self._is_some { + self + } else { + default() + } + } + + // If only one of the two Options is Some, return that option. + // Otherwise, if both options are Some or both are None, None is returned. + fn xor(self, other: Self) -> Self { + if self._is_some { + if other._is_some { + Option::none() + } else { + self + } + } else if other._is_some { + other + } else { + Option::none() + } + } + + /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. + /// Otherwise, this returns `None` + fn filter(self, predicate: fn(T) -> bool) -> Self { + if self._is_some { + if predicate(self._value) { + self + } else { + Option::none() + } + } else { + Option::none() + } + } + + /// Flattens an Option> into a Option. + /// This returns None if the outer Option is None. Otherwise, this returns the inner Option. + fn flatten(option: Option>) -> Option { + if option._is_some { + option._value + } else { + Option::none() + } + } +} diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr index 5000efd3be4..1e69bcec821 100644 --- a/noir_stdlib/src/schnorr.nr +++ b/noir_stdlib/src/schnorr.nr @@ -1,2 +1,2 @@ #[foreign(schnorr_verify)] -fn verify_signature(_public_key_x: Field, _public_key_y: Field, _signature: [u8; 64], _message: [u8]) -> bool {} +fn verify_signature(_public_key_x: Field, _public_key_y: Field, _signature: [u8; 64], _message: [u8; N]) -> bool {} diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr index 186d535a264..8e344a40f5e 100644 --- a/noir_stdlib/src/slice.nr +++ b/noir_stdlib/src/slice.nr @@ -32,74 +32,5 @@ impl [T] { /// the removed element #[builtin(slice_remove)] fn remove(_self: Self, _index: Field) -> (Self, T) { } - - #[builtin(array_len)] - fn len(_self: Self) -> comptime Field {} - - #[builtin(arraysort)] - fn sort(_self: Self) -> Self {} - - // Sort with a custom sorting function. - fn sort_via(mut a: Self, ordering: fn(T, T) -> bool) -> Self { - for i in 1 .. a.len() { - for j in 0..i { - if ordering(a[i], a[j]) { - let old_a_j = a[j]; - a[j] = a[i]; - a[i] = old_a_j; - } - } - } - a - } - - // Apply a function to each element of a slice, returning a new slice - // containing the mapped elements. - fn map(self, f: fn(T) -> U) -> [U] { - let mut ret: [U] = []; - for elem in self { - ret = ret.push_back(f(elem)); - } - ret - } - - // Apply a function to each element of the slice and an accumulator value, - // returning the final accumulated value. This function is also sometimes - // called `foldl`, `fold_left`, `reduce`, or `inject`. - fn fold(self, mut accumulator: U, f: fn(U, T) -> U) -> U { - for elem in self { - accumulator = f(accumulator, elem); - } - accumulator - } - - // Apply a function to each element of the slice and an accumulator value, - // returning the final accumulated value. Unlike fold, reduce uses the first - // element of the given slice as its starting accumulator value. - fn reduce(self, f: fn(T, T) -> T) -> T { - let mut accumulator = self[0]; - for i in 1 .. self.len() { - accumulator = f(accumulator, self[i]); - } - accumulator - } - - // Returns true if all elements in the array satisfy the predicate - fn all(self, predicate: fn(T) -> bool) -> bool { - let mut ret = true; - for elem in self { - ret &= predicate(elem); - } - ret - } - - // Returns true if any element in the array satisfies the predicate - fn any(self, predicate: fn(T) -> bool) -> bool { - let mut ret = false; - for elem in self { - ret |= predicate(elem); - } - ret - } }