chore: Integrate concrete-optimizer in the mono-repo

.github/workflows/compiler.yml

@@ -0,0 +1,79 @@
+name: Continuous integration - compiler
+
+on:
+  push:
+    branches: [ main, testci ]
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  conditions:
+    runs-on: ubuntu-20.04
+    outputs:
+      proceed: ${{ steps.interface-changes.outputs.any_changed == 'true' || github.ref == 'refs/heads/main' }}
+    steps:
+      - name: Code checkout
+        uses: actions/checkout@v3
+
+      - name: Detect changes on API to compiler
+        uses: tj-actions/changed-files@v34
+        id: interface-changes
+        with:
+          files: |
+            concrete-optimizer-cpp/src/cpp/*
+
+      - run: echo ${{ steps.interface-changes.outputs.any_changed }}
+
+  check-compiler-compatibility:
+    runs-on: ubuntu-20.04
+    needs: conditions
+    if: ${{ needs.conditions.outputs.proceed == 'true' }}
+    steps:
+      # A SSH private key is required as some dependencies are from private repos
+      - name: Set ssh keys
+        uses: webfactory/ssh-agent@v0.6.0
+        with:
+          ssh-private-key: ${{ secrets.CONCRETE_COMPILER_CI_SSH_PRIVATE }}
+
+      - name: Compiler checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+          repository: zama-ai/concrete-compiler-internal
+          ssh-key: ${{ secrets.CONCRETE_COMPILER_CI_SSH_PRIVATE }}
+
+      - name: Override optimizer for compiler
+        uses: actions/checkout@v3
+        with:
+          path: compiler/concrete-optimizer
+
+      - name: Install rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Download cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Concrete-Optimizer
+        run: |
+          cd compiler
+          make concrete-optimizer-lib
+
+      - name: Build compiler
+        uses: addnab/docker-run-action@v3
+        with:
+          registry: ghcr.io
+          image: ghcr.io/zama-ai/concrete-compiler
+          username: zama-bot
+          password: ${{ secrets.ZAMA_BOT_TOKEN }}
+          options: >-
+            -v ${{ github.workspace }}/compiler:/compiler
+          shell: bash
+          run: |
+            set -e
+            cd /compiler
+            export PYTHONPATH=""
+            make CCACHE=ON BUILD_DIR=/build concretecompiler

.github/workflows/optimizer.yml

@@ -0,0 +1,109 @@
+name: Continuous integration
+
+on:
+  push:
+    branches: [ main, testci ]
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+jobs:
+  check-concrete-optimizer:
+    strategy:
+      matrix:
+        os: [ubuntu-20.04, macos-11]
+    runs-on: ${{ matrix.os }}
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: "Setup"
+        uses: ./.github/workflows/setup
+        with:
+          ssh_private_key: ${{ secrets.CONCRETE_COMPILER_CI_SSH_PRIVATE }}
+
+      - name: Formatting
+        run: cargo fmt --check
+
+      - name: Build
+        run: cargo build --release --all-targets
+
+      - name: Lint
+        run: cargo clippy --release --all-targets
+
+      - name: Tests
+        if: matrix.os == 'ubuntu-20.04'
+        run: |
+          cargo test --release --no-fail-fast --all-targets
+          make -C concrete-optimizer-cpp test-ci
+      
+  benchmark-concrete-optimizer:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: "Setup"
+        uses: ./.github/workflows/setup
+        with:
+          ssh_private_key: ${{ secrets.CONCRETE_COMPILER_CI_SSH_PRIVATE }}
+
+      - name: Run benchmark
+        run: cargo bench -p v0-parameters -- --output-format bencher | tee bench_result.txt
+
+      - name: Download PR base benchmark data
+        if: ${{ github.event_name == 'pull_request' }}
+        # for artifacts restrictions see https://github.com/actions/download-artifact/issues/3
+        # for cache restrictions see https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache
+        # and  https://github.com/actions/cache/issues/692
+        uses: dawidd6/action-download-artifact@v2
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          workflow_conclusion: success
+          commit: ${{ github.event.pull_request.base.sha }}
+          name: ${{ runner.os }}-benchmark
+          if_no_artifact_found: warn
+          path: ./benchmark
+      
+      - name: Save benchmark result to file
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'cargo'
+          output-file-path: bench_result.txt
+          external-data-json-path: ./benchmark/benchmark-data.json
+          # GitHub API token to make a commit comment
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          # Enable alert commit comment
+          comment-always: true
+
+      - name: Upload benchmark data
+        uses: actions/upload-artifact@v3
+        with:
+          path: ./benchmark
+          name: ${{ runner.os }}-benchmark
+          
+          
+
+  nightly-check-concrete-optimizer:
+    runs-on: ubuntu-20.04
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v3
+      - name: Rust install
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+          components: rustfmt, clippy
+      # A SSH private key is required as some dependencies are from private repos
+      - name: Set ssh keys
+        uses: webfactory/ssh-agent@v0.6.0
+        with:
+          ssh-private-key: ${{ secrets.CONCRETE_COMPILER_CI_SSH_PRIVATE }}
+      - name: Formatting
+        run: cargo fmt --check
+
+      - name: Lint
+        run: cargo clippy --release --all-targets
+

.github/workflows/setup/action.yml

@@ -0,0 +1,21 @@
+inputs:
+  ssh_private_key:
+    description: 'A ssh key to access private github repository'
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Rust install
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+
+    - name: Download cargo cache
+      uses: Swatinem/rust-cache@v2
+
+    # A SSH private key is required as some dependencies are from private repos
+    - name: Set ssh keys
+      uses: webfactory/ssh-agent@v0.6.0
+      with:
+        ssh-private-key: ${{ inputs.ssh_private_key }}

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

.rustfmt.toml

@@ -0,0 +1 @@
+imports_granularity = "Module"

compilers/concrete-optimizer/Cargo.toml

@@ -0,0 +1,15 @@
+[workspace]
+
+members = [
+    "concrete-optimizer",
+    "v0-parameters",
+    "concrete-optimizer-cpp",
+    "charts",
+]
+
+
+[profile.test]
+overflow-checks = true
+
+[profile.release]
+overflow-checks = true

compilers/concrete-optimizer/LICENSE

@@ -0,0 +1,26 @@
+BSD 3-Clause Clear License
+Copyright © 2022 ZAMA.
+All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or other
+materials provided with the distribution.
+3. Neither the name of ZAMA nor the names of its contributors may be used to endorse
+or promote products derived from this software without specific prior written permission.
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE*.
+THIS SOFTWARE IS PROVIDED BY THE ZAMA AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ZAMA OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*In addition to the rights carried by this license, ZAMA grants to the user a non-exclusive,
+free and non-commercial license on all patents filed in its name relating to the open-source
+code (the "Patents") for the sole purpose of evaluation, development, research, prototyping
+and experimentation.

compilers/concrete-optimizer/charts/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "charts"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+concrete-optimizer = { path ="../concrete-optimizer" }
+plotters = "0.3.1"
+
+[lib]
+crate-type= [
+    "lib",       # rust
+]
+
+[[bin]]
+name = "precision_complexity"
+
+[[bin]]
+name = "norm2_complexity"
+

compilers/concrete-optimizer/charts/src/bin/norm2_complexity.rs

@@ -0,0 +1,101 @@
+use charts::{draw, Serie};
+use concrete_optimizer::computing_cost::cpu::CpuComplexity;
+use concrete_optimizer::config;
+use concrete_optimizer::global_parameters::DEFAUT_DOMAINS;
+use concrete_optimizer::optimization::atomic_pattern::{self as optimize_atomic_pattern};
+use concrete_optimizer::optimization::config::{Config, SearchSpace};
+use concrete_optimizer::optimization::decomposition;
+use concrete_optimizer::optimization::wop_atomic_pattern::optimize as optimize_wop_atomic_pattern;
+
+pub const _4_SIGMA: f64 = 1.0 - 0.999_936_657_516;
+const MIN_LOG_POLY_SIZE: u64 = DEFAUT_DOMAINS
+    .glwe_pbs_constrained
+    .log2_polynomial_size
+    .start;
+const MAX_LOG_POLY_SIZE: u64 = DEFAUT_DOMAINS.glwe_pbs_constrained.log2_polynomial_size.end - 1;
+pub const MAX_GLWE_DIM: u64 = DEFAUT_DOMAINS.glwe_pbs_constrained.glwe_dimension.end - 1;
+pub const MIN_LWE_DIM: u64 = DEFAUT_DOMAINS.free_glwe.glwe_dimension.start;
+pub const MAX_LWE_DIM: u64 = DEFAUT_DOMAINS.free_glwe.glwe_dimension.end - 1;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let sum_size = 4096;
+    let p_error = _4_SIGMA;
+    let security_level = 128;
+    let glwe_log_polynomial_sizes: Vec<_> = (MIN_LOG_POLY_SIZE..=MAX_LOG_POLY_SIZE).collect();
+    let glwe_dimensions: Vec<_> = (1..=6).collect();
+    let internal_lwe_dimensions: Vec<_> = (MIN_LWE_DIM..=MAX_LWE_DIM).step_by(10).collect();
+
+    let processing_unit = config::ProcessingUnit::Cpu;
+
+    let search_space = SearchSpace {
+        glwe_log_polynomial_sizes,
+        glwe_dimensions,
+        internal_lwe_dimensions,
+    };
+
+    let precision = 8;
+    let log_norm2s = 1_u64..=31;
+
+    let config = Config {
+        security_level,
+        maximum_acceptable_error_probability: p_error,
+        ciphertext_modulus_log: 64,
+        complexity_model: &CpuComplexity::default(),
+    };
+
+    let cache = decomposition::cache(security_level, processing_unit, None, true);
+
+    let solutions: Vec<_> = log_norm2s
+        .clone()
+        .filter_map(|log_norm2| {
+            let noise_scale = 2_f64.powi(log_norm2 as i32);
+
+            optimize_atomic_pattern::optimize_one(
+                sum_size,
+                precision,
+                config,
+                noise_scale,
+                &search_space,
+                &cache,
+            )
+            .best_solution
+            .map(|a| (log_norm2, a.complexity))
+        })
+        .collect();
+
+    let wop_solutions: Vec<_> = log_norm2s
+        .filter_map(|log_norm2| {
+            let noise_scale = 2_f64.powi(log_norm2 as i32);
+
+            optimize_wop_atomic_pattern::optimize_one(
+                precision,
+                config,
+                noise_scale,
+                &search_space,
+                &cache,
+            )
+            .best_solution
+            .map(|a| (log_norm2, a.complexity))
+        })
+        .collect();
+
+    draw(
+        "comparison_cggi_bbbclot_norm2_vs_complexity.png",
+        &format!("Comparison CGGI vs BBBCLOT for precision={precision}"),
+        &[
+            Serie {
+                label: "CGGI AP Complexity".to_owned(),
+                values: solutions,
+            },
+            Serie {
+                label: "BBBCLOT AP Complexity".to_owned(),
+                values: wop_solutions,
+            },
+        ],
+        (1024, 1024),
+        "Log Norm2",
+        "Complexity",
+    )?;
+
+    Ok(())
+}

compilers/concrete-optimizer/charts/src/bin/precision_complexity.rs

@@ -0,0 +1,99 @@
+use charts::{draw, Serie};
+use concrete_optimizer::computing_cost::cpu::CpuComplexity;
+use concrete_optimizer::config;
+use concrete_optimizer::global_parameters::DEFAUT_DOMAINS;
+use concrete_optimizer::optimization::atomic_pattern::{self as optimize_atomic_pattern};
+use concrete_optimizer::optimization::config::{Config, SearchSpace};
+use concrete_optimizer::optimization::decomposition;
+use concrete_optimizer::optimization::wop_atomic_pattern::optimize as optimize_wop_atomic_pattern;
+
+pub const _4_SIGMA: f64 = 1.0 - 0.999_936_657_516;
+const MIN_LOG_POLY_SIZE: u64 = DEFAUT_DOMAINS
+    .glwe_pbs_constrained
+    .log2_polynomial_size
+    .start;
+const MAX_LOG_POLY_SIZE: u64 = DEFAUT_DOMAINS.glwe_pbs_constrained.log2_polynomial_size.end - 1;
+pub const MAX_GLWE_DIM: u64 = DEFAUT_DOMAINS.glwe_pbs_constrained.glwe_dimension.end - 1;
+pub const MIN_LWE_DIM: u64 = DEFAUT_DOMAINS.free_glwe.glwe_dimension.start;
+pub const MAX_LWE_DIM: u64 = DEFAUT_DOMAINS.free_glwe.glwe_dimension.end - 1;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let processing_unit = config::ProcessingUnit::Cpu;
+
+    let sum_size = 4096;
+    let p_error = _4_SIGMA;
+    let security_level = 128;
+    let glwe_log_polynomial_sizes: Vec<_> = (MIN_LOG_POLY_SIZE..=MAX_LOG_POLY_SIZE).collect();
+    let glwe_dimensions: Vec<_> = (1..=6).collect();
+    let internal_lwe_dimensions: Vec<_> = (MIN_LWE_DIM..=MAX_LWE_DIM).step_by(10).collect();
+
+    let precisions = 1..=16;
+    let log_norm2 = 10;
+
+    let search_space = SearchSpace {
+        glwe_log_polynomial_sizes,
+        glwe_dimensions,
+        internal_lwe_dimensions,
+    };
+
+    let config = Config {
+        security_level,
+        maximum_acceptable_error_probability: p_error,
+        ciphertext_modulus_log: 64,
+        complexity_model: &CpuComplexity::default(),
+    };
+
+    let cache = decomposition::cache(security_level, processing_unit, None, true);
+
+    let solutions: Vec<_> = precisions
+        .clone()
+        .filter_map(|precision| {
+            let noise_factor = (log_norm2 as f64).exp2();
+
+            optimize_atomic_pattern::optimize_one(
+                sum_size,
+                precision,
+                config,
+                noise_factor,
+                &search_space,
+                &cache,
+            )
+            .best_solution
+            .map(|a| (precision, a.complexity))
+        })
+        .collect();
+
+    let wop_solutions: Vec<_> = precisions
+        .filter_map(|precision| {
+            optimize_wop_atomic_pattern::optimize_one(
+                precision,
+                config,
+                log_norm2 as f64,
+                &search_space,
+                &cache,
+            )
+            .best_solution
+            .map(|a| (precision, a.complexity))
+        })
+        .collect();
+
+    draw(
+        "comparison_cggi_bbbclot_precision_vs_complexity.png",
+        &format!("Comparison CGGI vs BBBCLOT for log_norm2={log_norm2}"),
+        &[
+            Serie {
+                label: "PBS Complexity".to_owned(),
+                values: solutions,
+            },
+            Serie {
+                label: "WoPPBS Complexity".to_owned(),
+                values: wop_solutions,
+            },
+        ],
+        (1024, 1024),
+        "Precision",
+        "Complexity",
+    )?;
+
+    Ok(())
+}

compilers/concrete-optimizer/charts/src/lib.rs

@@ -0,0 +1,86 @@
+#![warn(clippy::nursery)]
+#![warn(clippy::pedantic)]
+#![warn(clippy::style)]
+#![allow(clippy::cast_precision_loss)] // u64 to f64
+#![allow(clippy::cast_possible_truncation)] // u64 to usize
+#![allow(clippy::cast_sign_loss)]
+#![allow(clippy::must_use_candidate)]
+#![allow(clippy::missing_panics_doc)]
+#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::range_plus_one)]
+
+use plotters::prelude::*;
+
+pub struct Serie {
+    pub label: String,
+    pub values: Vec<(u64, f64)>,
+}
+
+pub fn draw(
+    path: &str,
+    caption: &str,
+    series: &[Serie],
+    resolution: (u32, u32),
+    x_description: &str,
+    y_description: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mut min_x = u64::MAX;
+    let mut max_x = 0;
+
+    let mut min_y = f64::INFINITY;
+    let mut max_y = f64::NEG_INFINITY;
+
+    for Serie { values, .. } in series.iter() {
+        for &(x, y) in values.iter() {
+            if x < min_x {
+                min_x = x;
+            }
+            if max_x < x {
+                max_x = x;
+            }
+            if y < min_y {
+                min_y = y;
+            }
+            if max_y < y {
+                max_y = y;
+            }
+        }
+    }
+
+    let root = BitMapBackend::new(path, resolution).into_drawing_area();
+    root.fill(&WHITE)?;
+
+    let mut chart = ChartBuilder::on(&root)
+        .caption(caption, ("sans-serif", 25).into_font())
+        .margin(5)
+        .x_label_area_size(50)
+        .y_label_area_size(100)
+        .build_cartesian_2d(
+            (min_x - 1)..(max_x + 1),
+            ((min_y / 2.)..(max_y * 2.)).log_scale(),
+        )?;
+
+    chart
+        .configure_mesh()
+        .x_desc(x_description)
+        .y_desc(y_description)
+        .y_label_formatter(&|y| format!("{y:+e}"))
+        .draw()?;
+
+    for (idx, Serie { label, values }) in series.iter().enumerate() {
+        let color = Palette99::pick(idx).mix(0.9);
+
+        chart
+            .draw_series(LineSeries::new(values.clone(), color.filled()))?
+            .label(label)
+            .legend(move |(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], color.filled()));
+    }
+
+    chart
+        .configure_series_labels()
+        .background_style(WHITE.mix(0.8))
+        .border_style(BLACK)
+        .draw()?;
+
+    Ok(())
+}

compilers/concrete-optimizer/concrete-optimizer-cpp/.gitignore

@@ -0,0 +1 @@
+tests/tests_exe

compilers/concrete-optimizer/concrete-optimizer-cpp/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+# see https://doc.rust-lang.org/cargo/reference/manifest.html
+name = "concrete-optimizer-cpp"
+version = "0.1.0"
+authors = [""]
+edition = "2021"
+
+[dependencies]
+cxx = "1.0"
+concrete-optimizer = {path = "../concrete-optimizer" }
+
+[build-dependencies]
+cxx-build = "1.0"
+
+[lib]
+path = "src/concrete-optimizer.rs"
+crate-type = ["staticlib"]

compilers/concrete-optimizer/concrete-optimizer-cpp/Makefile

@@ -0,0 +1,50 @@
+# dev or release
+CARGO_PROFILE ?= release
+# debug or release
+PROFILE_SUBDIR ?= release
+
+MAKEFILE_DIR := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+ROOT = $(realpath $(MAKEFILE_DIR)/..)
+CXXBRIDGE_DIR = $(ROOT)/target/cxxbridge/concrete-optimizer-cpp/src
+
+# In target intermediate files
+INTERFACE_LIB_ORIG = $(ROOT)/target/$(PROFILE_SUBDIR)/libconcrete_optimizer_cpp.a
+INTERFACE_HEADER_ORIG = $(CXXBRIDGE_DIR)/concrete-optimizer.rs.h
+INTERFACE_CPP_ORIG = $(CXXBRIDGE_DIR)/concrete-optimizer.rs.cc
+
+# Final files
+INTERFACE_LIB = $(ROOT)/target/libconcrete_optimizer_cpp.a
+INTERFACE_HEADER = src/cpp/concrete-optimizer.hpp
+INTERFACE_CPP =  src/cpp/concrete-optimizer.cpp
+
+SOURCES = $(shell find $(ROOT)/concrete-optimizer/src) \
+	$(shell find $(ROOT)/concrete-optimizer-cpp/src -name '*.rs')
+
+build: $(INTERFACE_LIB)
+
+$(INTERFACE_LIB_ORIG) $(INTERFACE_HEADER_ORIG) $(INTERFACE_CPP_ORIG): $(SOURCES)
+	cd $(ROOT) && cargo build -p concrete-optimizer-cpp --profile $(CARGO_PROFILE)
+
+$(INTERFACE_HEADER): $(INTERFACE_HEADER_ORIG)
+	cp $< $@
+
+$(INTERFACE_CPP): $(INTERFACE_CPP_ORIG)
+	cp $< $@
+
+$(INTERFACE_LIB): $(INTERFACE_LIB_ORIG)
+	cp $< $@
+
+TESTS_SOURCES = tests/src/main.cpp
+TEST_DEP_LIBS = -l pthread -ldl
+tests/tests_exe: $(INTERFACE_LIB) $(INTERFACE_HEADER) $(INTERFACE_CPP) $(TESTS_SOURCES)
+	g++ -Wall -Werror -Wextra -o $@ $(TESTS_SOURCES) $(INTERFACE_CPP) $(INTERFACE_LIB) -I $(shell dirname $(INTERFACE_HEADER)) $(TEST_DEP_LIBS)
+	chmod +x $@
+
+test: tests/tests_exe
+	./tests/tests_exe
+
+test-ci:
+	# force regeneration of sources
+	rm -rf $(INTERFACE_HEADER) $(INTERFACE_CPP) $(INTERFACE_HEADER_ORIG) $(INTERFACE_CPP_ORIG)
+	$(MAKE) CARGO_PROFILE=dev PROFILE_SUBDIR=debug test
+	git diff --exit-code src/cpp || (echo Please commit the new version of generated files && exit 1)

compilers/concrete-optimizer/concrete-optimizer-cpp/build.rs

@@ -0,0 +1,5 @@
+fn main() {
+    let _build = cxx_build::bridge("src/concrete-optimizer.rs");
+
+    println!("cargo:rerun-if-changed=src/");
+}

compilers/concrete-optimizer/concrete-optimizer-cpp/cmake-utils/CMakeLists.txt

@@ -0,0 +1,16 @@
+# In your project CMakeLists.txt:
+# 1. define the path containing concrete-optimizer repository, builded.
+# CONCRETE_OPTIMIZER_DIR
+# 2. add lines:
+# add_subdirectory(${CONCRETE_OPTIMIZER_DIR}/concrete-optimizer-cpp/cmake-utils)
+# include_directories(${CONCRETE_OPTIMIZER_DIR}/concrete-optimizer-cpp/src/cpp)
+
+add_library(concrete_optimizer STATIC ${CONCRETE_OPTIMIZER_DIR}/concrete-optimizer-cpp/src/cpp/concrete-optimizer.cpp)
+
+target_link_libraries(concrete_optimizer PRIVATE
+  pthread m dl
+  "${CONCRETE_OPTIMIZER_DIR}/target/libconcrete_optimizer_cpp.a"
+)
+
+install(TARGETS concrete_optimizer EXPORT concrete_optimizer)
+install(EXPORT concrete_optimizer DESTINATION "./")

compilers/concrete-optimizer/concrete-optimizer-cpp/src/concrete-optimizer.rs

@@ -0,0 +1,458 @@
+use concrete_optimizer::computing_cost::cpu::CpuComplexity;
+use concrete_optimizer::config;
+use concrete_optimizer::config::ProcessingUnit;
+use concrete_optimizer::dag::operator::{
+    self, FunctionTable, LevelledComplexity, OperatorIndex, Precision, Shape,
+};
+use concrete_optimizer::dag::unparametrized;
+use concrete_optimizer::optimization::config::{Config, SearchSpace};
+use concrete_optimizer::optimization::dag::solo_key::optimize_generic::{
+    Encoding, Solution as DagSolution,
+};
+use concrete_optimizer::optimization::decomposition;
+use concrete_optimizer::utils::cache::persistent::default_cache_dir;
+
+fn no_solution() -> ffi::Solution {
+    ffi::Solution {
+        p_error: 1.0, // error probability to signal an impossible solution
+        ..ffi::Solution::default()
+    }
+}
+
+fn no_dag_solution() -> ffi::DagSolution {
+    ffi::DagSolution {
+        p_error: 1.0, // error probability to signal an impossible solution
+        ..ffi::DagSolution::default()
+    }
+}
+
+fn caches_from(options: ffi::Options) -> decomposition::PersistDecompCaches {
+    if !options.cache_on_disk {
+        println!("optimizer: Using stateless cache.");
+        let cache_dir = default_cache_dir();
+        println!("optimizer: To clear the cache, remove directory {cache_dir}");
+    }
+    let processing_unit = processing_unit(options);
+    decomposition::cache(
+        options.security_level,
+        processing_unit,
+        Some(ProcessingUnit::Cpu.complexity_model()),
+        options.cache_on_disk,
+    )
+}
+
+fn optimize_bootstrap(precision: u64, noise_factor: f64, options: ffi::Options) -> ffi::Solution {
+    let processing_unit = processing_unit(options);
+
+    let config = Config {
+        security_level: options.security_level,
+        maximum_acceptable_error_probability: options.maximum_acceptable_error_probability,
+        ciphertext_modulus_log: 64,
+        complexity_model: &CpuComplexity::default(),
+    };
+
+    let sum_size = 1;
+
+    let search_space = SearchSpace::default(processing_unit);
+
+    let result = concrete_optimizer::optimization::atomic_pattern::optimize_one(
+        sum_size,
+        precision,
+        config,
+        noise_factor,
+        &search_space,
+        &caches_from(options),
+    );
+    result
+        .best_solution
+        .map_or_else(no_solution, |solution| solution.into())
+}
+
+fn convert_to_dag_solution(sol: &ffi::Solution) -> ffi::DagSolution {
+    sol.into()
+}
+
+impl From<&ffi::Solution> for ffi::DagSolution {
+    fn from(sol: &ffi::Solution) -> Self {
+        Self {
+            input_lwe_dimension: sol.input_lwe_dimension,
+            internal_ks_output_lwe_dimension: sol.internal_ks_output_lwe_dimension,
+            ks_decomposition_level_count: sol.ks_decomposition_level_count,
+            ks_decomposition_base_log: sol.ks_decomposition_base_log,
+            glwe_polynomial_size: sol.glwe_polynomial_size,
+            glwe_dimension: sol.glwe_dimension,
+            br_decomposition_level_count: sol.br_decomposition_level_count,
+            br_decomposition_base_log: sol.br_decomposition_base_log,
+            complexity: sol.complexity,
+            noise_max: sol.noise_max,
+            p_error: sol.p_error,
+            global_p_error: f64::NAN,
+            use_wop_pbs: false,
+            cb_decomposition_level_count: 0,
+            cb_decomposition_base_log: 0,
+            pp_decomposition_level_count: 0,
+            pp_decomposition_base_log: 0,
+            crt_decomposition: vec![],
+        }
+    }
+}
+
+impl From<concrete_optimizer::optimization::atomic_pattern::Solution> for ffi::Solution {
+    fn from(a: concrete_optimizer::optimization::atomic_pattern::Solution) -> Self {
+        Self {
+            input_lwe_dimension: a.input_lwe_dimension,
+            internal_ks_output_lwe_dimension: a.internal_ks_output_lwe_dimension,
+            ks_decomposition_level_count: a.ks_decomposition_level_count,
+            ks_decomposition_base_log: a.ks_decomposition_base_log,
+            glwe_polynomial_size: a.glwe_polynomial_size,
+            glwe_dimension: a.glwe_dimension,
+            br_decomposition_level_count: a.br_decomposition_level_count,
+            br_decomposition_base_log: a.br_decomposition_base_log,
+            complexity: a.complexity,
+            noise_max: a.noise_max,
+            p_error: a.p_error,
+        }
+    }
+}
+
+impl From<DagSolution> for ffi::DagSolution {
+    fn from(sol: DagSolution) -> Self {
+        match sol {
+            DagSolution::WpSolution(sol) => Self {
+                input_lwe_dimension: sol.input_lwe_dimension,
+                internal_ks_output_lwe_dimension: sol.internal_ks_output_lwe_dimension,
+                ks_decomposition_level_count: sol.ks_decomposition_level_count,
+                ks_decomposition_base_log: sol.ks_decomposition_base_log,
+                glwe_polynomial_size: sol.glwe_polynomial_size,
+                glwe_dimension: sol.glwe_dimension,
+                br_decomposition_level_count: sol.br_decomposition_level_count,
+                br_decomposition_base_log: sol.br_decomposition_base_log,
+                complexity: sol.complexity,
+                noise_max: sol.noise_max,
+                p_error: sol.p_error,
+                global_p_error: sol.global_p_error,
+                use_wop_pbs: false,
+                cb_decomposition_level_count: 0,
+                cb_decomposition_base_log: 0,
+                pp_decomposition_level_count: 0,
+                pp_decomposition_base_log: 0,
+                crt_decomposition: vec![],
+            },
+            DagSolution::WopSolution(sol) => Self {
+                input_lwe_dimension: sol.input_lwe_dimension,
+                internal_ks_output_lwe_dimension: sol.internal_ks_output_lwe_dimension,
+                ks_decomposition_level_count: sol.ks_decomposition_level_count,
+                ks_decomposition_base_log: sol.ks_decomposition_base_log,
+                glwe_polynomial_size: sol.glwe_polynomial_size,
+                glwe_dimension: sol.glwe_dimension,
+                br_decomposition_level_count: sol.br_decomposition_level_count,
+                br_decomposition_base_log: sol.br_decomposition_base_log,
+                complexity: sol.complexity,
+                noise_max: sol.noise_max,
+                p_error: sol.p_error,
+                global_p_error: f64::NAN,
+                use_wop_pbs: true,
+                cb_decomposition_level_count: sol.cb_decomposition_level_count,
+                cb_decomposition_base_log: sol.cb_decomposition_base_log,
+                pp_decomposition_level_count: sol.pp_decomposition_level_count,
+                pp_decomposition_base_log: sol.pp_decomposition_base_log,
+                crt_decomposition: sol.crt_decomposition,
+            },
+        }
+    }
+}
+
+pub struct OperationDag(unparametrized::OperationDag);
+
+fn empty() -> Box<OperationDag> {
+    Box::new(OperationDag(unparametrized::OperationDag::new()))
+}
+
+impl OperationDag {
+    fn add_input(&mut self, out_precision: Precision, out_shape: &[u64]) -> ffi::OperatorIndex {
+        let out_shape = Shape {
+            dimensions_size: out_shape.to_owned(),
+        };
+
+        self.0.add_input(out_precision, out_shape).into()
+    }
+
+    fn add_lut(
+        &mut self,
+        input: ffi::OperatorIndex,
+        table: &[u64],
+        out_precision: Precision,
+    ) -> ffi::OperatorIndex {
+        let table = FunctionTable {
+            values: table.to_owned(),
+        };
+
+        self.0.add_lut(input.into(), table, out_precision).into()
+    }
+
+    #[allow(clippy::boxed_local)]
+    fn add_dot(
+        &mut self,
+        inputs: &[ffi::OperatorIndex],
+        weights: Box<Weights>,
+    ) -> ffi::OperatorIndex {
+        let inputs: Vec<OperatorIndex> = inputs.iter().copied().map(Into::into).collect();
+
+        self.0.add_dot(inputs, weights.0).into()
+    }
+
+    fn add_levelled_op(
+        &mut self,
+        inputs: &[ffi::OperatorIndex],
+        lwe_dim_cost_factor: f64,
+        fixed_cost: f64,
+        manp: f64,
+        out_shape: &[u64],
+        comment: &str,
+    ) -> ffi::OperatorIndex {
+        let inputs: Vec<OperatorIndex> = inputs.iter().copied().map(Into::into).collect();
+
+        let out_shape = Shape {
+            dimensions_size: out_shape.to_owned(),
+        };
+
+        let complexity = LevelledComplexity {
+            lwe_dim_cost_factor,
+            fixed_cost,
+        };
+
+        self.0
+            .add_levelled_op(inputs, complexity, manp, out_shape, comment)
+            .into()
+    }
+
+    fn add_round_op(
+        &mut self,
+        input: ffi::OperatorIndex,
+        rounded_precision: Precision,
+    ) -> ffi::OperatorIndex {
+        self.0.add_round_op(input.into(), rounded_precision).into()
+    }
+
+    fn optimize_v0(&self, options: ffi::Options) -> ffi::Solution {
+        let processing_unit = processing_unit(options);
+
+        let config = Config {
+            security_level: options.security_level,
+            maximum_acceptable_error_probability: options.maximum_acceptable_error_probability,
+            ciphertext_modulus_log: 64,
+            complexity_model: &CpuComplexity::default(),
+        };
+
+        let search_space = SearchSpace::default(processing_unit);
+
+        let result = concrete_optimizer::optimization::dag::solo_key::optimize::optimize(
+            &self.0,
+            config,
+            &search_space,
+            &caches_from(options),
+        );
+        result
+            .best_solution
+            .map_or_else(no_solution, |solution| solution.into())
+    }
+
+    fn optimize(&self, options: ffi::Options) -> ffi::DagSolution {
+        let processing_unit = processing_unit(options);
+        let config = Config {
+            security_level: options.security_level,
+            maximum_acceptable_error_probability: options.maximum_acceptable_error_probability,
+            ciphertext_modulus_log: 64,
+            complexity_model: &CpuComplexity::default(),
+        };
+
+        let search_space = SearchSpace::default(processing_unit);
+
+        let encoding = options.encoding.into();
+        let result = concrete_optimizer::optimization::dag::solo_key::optimize_generic::optimize(
+            &self.0,
+            config,
+            &search_space,
+            encoding,
+            options.default_log_norm2_woppbs,
+            &caches_from(options),
+        );
+        result.map_or_else(no_dag_solution, |solution| solution.into())
+    }
+
+    fn dump(&self) -> String {
+        self.0.dump()
+    }
+}
+
+pub struct Weights(operator::Weights);
+
+fn vector(weights: &[i64]) -> Box<Weights> {
+    Box::new(Weights(operator::Weights::vector(weights)))
+}
+
+impl From<OperatorIndex> for ffi::OperatorIndex {
+    fn from(oi: OperatorIndex) -> Self {
+        Self { index: oi.i }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<OperatorIndex> for ffi::OperatorIndex {
+    fn into(self) -> OperatorIndex {
+        OperatorIndex { i: self.index }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<Encoding> for ffi::Encoding {
+    fn into(self) -> Encoding {
+        match self {
+            Self::Auto => Encoding::Auto,
+            Self::Native => Encoding::Native,
+            Self::Crt => Encoding::Crt,
+            _ => unreachable!("Internal error: Invalid encoding"),
+        }
+    }
+}
+
+#[allow(unused_must_use)]
+#[cxx::bridge]
+mod ffi {
+
+    #[namespace = "concrete_optimizer"]
+    extern "Rust" {
+
+        #[namespace = "concrete_optimizer::v0"]
+        fn optimize_bootstrap(precision: u64, noise_factor: f64, options: Options) -> Solution;
+
+        #[namespace = "concrete_optimizer::utils"]
+        fn convert_to_dag_solution(solution: &Solution) -> DagSolution;
+
+        type OperationDag;
+
+        #[namespace = "concrete_optimizer::dag"]
+        fn empty() -> Box<OperationDag>;
+
+        fn add_input(
+            self: &mut OperationDag,
+            out_precision: u8,
+            out_shape: &[u64],
+        ) -> OperatorIndex;
+
+        fn add_lut(
+            self: &mut OperationDag,
+            input: OperatorIndex,
+            table: &[u64],
+            out_precision: u8,
+        ) -> OperatorIndex;
+
+        fn add_dot(
+            self: &mut OperationDag,
+            inputs: &[OperatorIndex],
+            weights: Box<Weights>,
+        ) -> OperatorIndex;
+
+        fn add_levelled_op(
+            self: &mut OperationDag,
+            inputs: &[OperatorIndex],
+            lwe_dim_cost_factor: f64,
+            fixed_cost: f64,
+            manp: f64,
+            out_shape: &[u64],
+            comment: &str,
+        ) -> OperatorIndex;
+
+        fn add_round_op(
+            self: &mut OperationDag,
+            input: OperatorIndex,
+            rounded_precision: u8,
+        ) -> OperatorIndex;
+
+        fn optimize_v0(self: &OperationDag, options: Options) -> Solution;
+
+        fn optimize(self: &OperationDag, options: Options) -> DagSolution;
+
+        fn dump(self: &OperationDag) -> String;
+
+        type Weights;
+
+        #[namespace = "concrete_optimizer::weights"]
+        fn vector(weights: &[i64]) -> Box<Weights>;
+    }
+
+    #[derive(Debug, Clone, Copy)]
+    #[namespace = "concrete_optimizer"]
+    pub enum Encoding {
+        Auto,
+        Native,
+        Crt,
+    }
+
+    #[derive(Clone, Copy)]
+    #[namespace = "concrete_optimizer::dag"]
+    struct OperatorIndex {
+        index: usize,
+    }
+
+    #[namespace = "concrete_optimizer::v0"]
+    #[derive(Debug, Clone, Copy, Default)]
+    pub struct Solution {
+        pub input_lwe_dimension: u64,              //n_big
+        pub internal_ks_output_lwe_dimension: u64, //n_small
+        pub ks_decomposition_level_count: u64,     //l(KS)
+        pub ks_decomposition_base_log: u64,        //b(KS)
+        pub glwe_polynomial_size: u64,             //N
+        pub glwe_dimension: u64,                   //k
+        pub br_decomposition_level_count: u64,     //l(BR)
+        pub br_decomposition_base_log: u64,        //b(BR)
+        pub complexity: f64,
+        pub noise_max: f64,
+        pub p_error: f64, // error probability
+    }
+
+    #[namespace = "concrete_optimizer::dag"]
+    #[derive(Debug, Clone, Default)]
+    pub struct DagSolution {
+        pub input_lwe_dimension: u64,              //n_big
+        pub internal_ks_output_lwe_dimension: u64, //n_small
+        pub ks_decomposition_level_count: u64,     //l(KS)
+        pub ks_decomposition_base_log: u64,        //b(KS)
+        pub glwe_polynomial_size: u64,             //N
+        pub glwe_dimension: u64,                   //k
+        pub br_decomposition_level_count: u64,     //l(BR)
+        pub br_decomposition_base_log: u64,        //b(BR)
+        pub complexity: f64,
+        pub noise_max: f64,
+        pub p_error: f64, // error probability
+        pub global_p_error: f64,
+        pub use_wop_pbs: bool,
+        pub cb_decomposition_level_count: u64,
+        pub cb_decomposition_base_log: u64,
+        pub pp_decomposition_level_count: u64,
+        pub pp_decomposition_base_log: u64,
+        pub crt_decomposition: Vec<u64>,
+    }
+
+    #[namespace = "concrete_optimizer"]
+    #[derive(Debug, Clone, Copy)]
+    pub struct Options {
+        pub security_level: u64,
+        pub maximum_acceptable_error_probability: f64,
+        pub default_log_norm2_woppbs: f64,
+        pub use_gpu_constraints: bool,
+        pub encoding: Encoding,
+        pub cache_on_disk: bool,
+    }
+}
+
+fn processing_unit(options: ffi::Options) -> ProcessingUnit {
+    if options.use_gpu_constraints {
+        config::ProcessingUnit::Gpu {
+            pbs_type: config::GpuPbsType::Amortized,
+            number_of_sm: 1,
+        }
+    } else {
+        config::ProcessingUnit::Cpu
+    }
+}

compilers/concrete-optimizer/concrete-optimizer-cpp/tests/src/main.cpp

@@ -0,0 +1,119 @@
+#include "concrete-optimizer.hpp"
+#include <cassert>
+#include <vector>
+
+template <typename T>
+rust::cxxbridge1::Slice<const T> slice(std::vector<T> &vec) {
+  const T *data = vec.data();
+
+  return rust::cxxbridge1::Slice<const T>(data, vec.size());
+}
+
+const uint64_t SECURITY_128B = 128;
+const double P_ERROR = 0.05;
+const double PRECISION_1B = 1;
+const double PRECISION_8B = 8;
+const double PRECISION_16B = 16;
+const double WOP_FALLBACK_LOG_NORM = 8;
+const double NOISE_DEVIATION_COEFF = 1.0;
+
+concrete_optimizer::Options default_options() {
+  return concrete_optimizer::Options {
+    .security_level = SECURITY_128B,
+    .maximum_acceptable_error_probability = P_ERROR,
+    .default_log_norm2_woppbs = WOP_FALLBACK_LOG_NORM,
+    .use_gpu_constraints = false,
+    .encoding = concrete_optimizer::Encoding::Auto,
+    .cache_on_disk = true,
+  };
+}
+
+void test_v0() {
+  concrete_optimizer::v0::Solution solution =
+      concrete_optimizer::v0::optimize_bootstrap(
+          PRECISION_1B, NOISE_DEVIATION_COEFF, default_options());
+
+  assert(solution.glwe_polynomial_size == 256);
+}
+
+void test_dag_no_lut() {
+  auto dag = concrete_optimizer::dag::empty();
+
+  std::vector<uint64_t> shape = {3};
+
+  concrete_optimizer::dag::OperatorIndex node1 =
+      dag->add_input(PRECISION_8B, slice(shape));
+
+  std::vector<concrete_optimizer::dag::OperatorIndex> inputs = {node1};
+
+  std::vector<int64_t> weight_vec = {1, 1, 1};
+
+  rust::cxxbridge1::Box<concrete_optimizer::Weights> weights =
+      concrete_optimizer::weights::vector(slice(weight_vec));
+
+  dag->add_dot(slice(inputs), std::move(weights));
+
+  auto solution = dag->optimize_v0(default_options());
+  assert(solution.glwe_polynomial_size == 256);
+}
+
+void test_dag_lut() {
+  auto dag = concrete_optimizer::dag::empty();
+
+  std::vector<uint64_t> shape = {3};
+
+  concrete_optimizer::dag::OperatorIndex input =
+      dag->add_input(PRECISION_8B, slice(shape));
+
+  std::vector<u_int64_t> table = {};
+  dag->add_lut(input, slice(table), PRECISION_8B);
+
+  auto solution = dag->optimize(default_options());
+  assert(solution.glwe_dimension == 1);
+  assert(solution.glwe_polynomial_size == 8192);
+  assert(!solution.use_wop_pbs);
+}
+
+void test_dag_lut_wop() {
+  auto dag = concrete_optimizer::dag::empty();
+
+  std::vector<uint64_t> shape = {3};
+
+  concrete_optimizer::dag::OperatorIndex input =
+      dag->add_input(PRECISION_16B, slice(shape));
+
+  std::vector<u_int64_t> table = {};
+  dag->add_lut(input, slice(table), PRECISION_16B);
+
+  auto solution = dag->optimize(default_options());
+  assert(solution.glwe_dimension == 2);
+  assert(solution.glwe_polynomial_size == 1024);
+  assert(solution.use_wop_pbs);
+}
+
+void test_dag_lut_force_wop() {
+  auto dag = concrete_optimizer::dag::empty();
+
+  std::vector<uint64_t> shape = {3};
+
+  concrete_optimizer::dag::OperatorIndex input =
+      dag->add_input(PRECISION_8B, slice(shape));
+
+  std::vector<u_int64_t> table = {};
+  dag->add_lut(input, slice(table), PRECISION_8B);
+
+  auto options = default_options();
+  options.encoding = concrete_optimizer::Encoding::Crt;
+  auto solution = dag->optimize(options);
+  assert(solution.use_wop_pbs);
+}
+
+int main() {
+  test_v0();
+  test_dag_no_lut();
+  test_dag_lut();
+  test_dag_lut_wop();
+  test_dag_lut_force_wop();
+
+  return 0;
+}

compilers/concrete-optimizer/concrete-optimizer/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "concrete-optimizer"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+concrete-security-curves = { git = "ssh://git@github.com/zama-ai/parameter-curves.git", rev = "05184593ada0eb1116a42a70674e6e3eea5e108e" }
+concrete-cpu-noise-model = { git = "ssh://git@github.com/zama-ai/concrete-cpu.git", rev = "91cff0bf1166d00f17d80b2ff03fcb48d161d43c" }
+file-lock = "2.1.6"
+serde = { version = "1.0", features = ["derive"] }
+bincode = "1.3"
+puruspe = "0.2.0"
+rustc-hash = "1.1"
+rand = "0.8"
+
+[dev-dependencies]
+approx = "0.5"
+once_cell = "1.16.0"
+pretty_assertions = "1.2.1"
+
+[lib]
+crate-type = [
+    "lib", # rust
+]

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/atomic_pattern.rs

@@ -0,0 +1,23 @@
+use super::complexity::Complexity;
+use super::complexity_model::ComplexityModel;
+use crate::parameters::AtomicPatternParameters;
+
+#[allow(dead_code)]
+pub fn atomic_pattern_complexity(
+    complexity_model: &dyn ComplexityModel,
+    sum_size: u64,
+    params: AtomicPatternParameters,
+    ciphertext_modulus_log: u32,
+) -> Complexity {
+    let multisum_complexity = complexity_model.levelled_complexity(
+        sum_size,
+        params.input_lwe_dimension,
+        ciphertext_modulus_log,
+    );
+    let ks_complexity =
+        complexity_model.ks_complexity(params.ks_parameters(), ciphertext_modulus_log);
+    let pbs_complexity =
+        complexity_model.pbs_complexity(params.pbs_parameters(), ciphertext_modulus_log);
+
+    multisum_complexity + ks_complexity + pbs_complexity
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/complexity.rs

@@ -0,0 +1,5 @@
+/** Global count of operations To simplify all operations (addition and multiplication) count for 1.
+ * But note that depending on the completexity model used it can be accurately proportional to the real exectution time.
+ * So complexities are only comparable inside the same complexity model.
+ */
+pub type Complexity = f64;

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/complexity_model.rs

@@ -0,0 +1,16 @@
+use super::complexity::Complexity;
+use crate::parameters::{CmuxParameters, KeyswitchParameters, LweDimension, PbsParameters};
+
+pub trait ComplexityModel: Send + Sync {
+    fn pbs_complexity(&self, params: PbsParameters, ciphertext_modulus_log: u32) -> Complexity;
+    fn cmux_complexity(&self, params: CmuxParameters, ciphertext_modulus_log: u32) -> Complexity;
+    fn ks_complexity(&self, params: KeyswitchParameters, ciphertext_modulus_log: u32)
+        -> Complexity;
+    fn fft_complexity(&self, glwe_polynomial_size: f64, ciphertext_modulus_log: u32) -> Complexity;
+    fn levelled_complexity(
+        &self,
+        sum_size: u64,
+        lwe_dimension: LweDimension,
+        ciphertext_modulus_log: u32,
+    ) -> Complexity;
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/cpu.rs

@@ -0,0 +1,53 @@
+use super::complexity::Complexity;
+use super::complexity_model::ComplexityModel;
+use super::operators::keyswitch_lwe::KsComplexity;
+use super::operators::{keyswitch_lwe, pbs};
+use crate::parameters::{CmuxParameters, KeyswitchParameters, LweDimension, PbsParameters};
+
+#[derive(Clone)]
+pub struct CpuComplexity {
+    pub ks_lwe: keyswitch_lwe::KsComplexity,
+    pub pbs: pbs::PbsComplexity,
+}
+
+impl ComplexityModel for CpuComplexity {
+    fn pbs_complexity(&self, params: PbsParameters, ciphertext_modulus_log: u32) -> Complexity {
+        self.pbs.complexity(params, ciphertext_modulus_log)
+    }
+
+    fn cmux_complexity(&self, params: CmuxParameters, ciphertext_modulus_log: u32) -> Complexity {
+        self.pbs.cmux.complexity(params, ciphertext_modulus_log)
+    }
+
+    fn ks_complexity(
+        &self,
+        params: KeyswitchParameters,
+        ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        self.ks_lwe.complexity(params, ciphertext_modulus_log)
+    }
+
+    fn fft_complexity(&self, glwe_polynomial_size: f64, ciphertext_modulus_log: u32) -> Complexity {
+        self.pbs
+            .cmux
+            .fft_complexity(glwe_polynomial_size, ciphertext_modulus_log)
+    }
+
+    fn levelled_complexity(
+        &self,
+        sum_size: u64,
+        lwe_dimension: LweDimension,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        sum_size as f64 * lwe_dimension.0 as f64
+    }
+}
+
+impl Default for CpuComplexity {
+    fn default() -> Self {
+        Self {
+            ks_lwe: KsComplexity,
+            pbs: pbs::PbsComplexity::default(),
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/fft.rs

@@ -0,0 +1,47 @@
+use super::complexity::Complexity;
+
+/** Standard fft complexity model */
+#[derive(Clone)]
+pub struct AsymptoticWithFactors {
+    factor_fft: f64,  // factor applied on asymptotic complexity
+    factor_ifft: f64, // factor applied on asymptotic complexity
+}
+
+impl AsymptoticWithFactors {
+    // https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/bootstrap.py#L109
+
+    #[inline] // forces to share log2 computation
+    pub fn fft_complexity(&self, size: f64) -> Complexity {
+        size * size.log2() * self.factor_fft
+    }
+
+    #[inline] // forces to share log2 computation
+    pub fn ifft_complexity(&self, size: f64) -> Complexity {
+        size * size.log2() * self.factor_ifft
+    }
+}
+
+impl Default for AsymptoticWithFactors {
+    fn default() -> Self {
+        Self {
+            factor_fft: 1.0,
+            factor_ifft: 1.0,
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use crate::computing_cost::fft;
+
+    #[test]
+    fn golden_python_prototype() {
+        let golden_fft = 664.385_618_977_472_4;
+        let actual_fft = fft::AsymptoticWithFactors::default().fft_complexity(100.);
+        approx::assert_relative_eq!(golden_fft, actual_fft, epsilon = f64::EPSILON);
+
+        let golden_ifft = 664.385_618_977_472_4;
+        let actual_ifft = fft::AsymptoticWithFactors::default().ifft_complexity(100.);
+        approx::assert_relative_eq!(golden_ifft, actual_ifft, epsilon = f64::EPSILON);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/gpu.rs

@@ -0,0 +1,89 @@
+use super::complexity::Complexity;
+use super::complexity_model::ComplexityModel;
+use crate::parameters::{CmuxParameters, KeyswitchParameters, LweDimension, PbsParameters};
+use crate::utils::square;
+
+#[derive(Clone, Copy)]
+pub enum GpuPbsComplexity {
+    Lowlat,
+    Amortized,
+}
+
+#[derive(Clone, Copy)]
+pub struct GpuKsComplexity;
+
+#[derive(Clone, Copy)]
+pub struct GpuComplexity {
+    pub ks: GpuKsComplexity,
+    pub pbs: GpuPbsComplexity,
+    pub number_of_sm: u64,
+}
+
+impl GpuComplexity {
+    pub fn default_lowlat_u64(number_of_sm: u64) -> Self {
+        Self {
+            ks: GpuKsComplexity,
+            pbs: GpuPbsComplexity::Lowlat,
+            number_of_sm,
+        }
+    }
+
+    pub fn default_amortized_u64(number_of_sm: u64) -> Self {
+        Self {
+            ks: GpuKsComplexity,
+            pbs: GpuPbsComplexity::Amortized,
+            number_of_sm,
+        }
+    }
+}
+
+impl ComplexityModel for GpuComplexity {
+    #[allow(clippy::let_and_return, non_snake_case)]
+    fn pbs_complexity(&self, _params: PbsParameters, _ciphertext_modulus_log: u32) -> Complexity {
+        todo!()
+    }
+
+    fn cmux_complexity(&self, _params: CmuxParameters, _ciphertext_modulus_log: u32) -> Complexity {
+        todo!()
+    }
+
+    #[allow(clippy::let_and_return)]
+    fn ks_complexity(
+        &self,
+        _params: KeyswitchParameters,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        todo!()
+    }
+
+    fn fft_complexity(
+        &self,
+        _glwe_polynomial_size: f64,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        todo!()
+    }
+
+    fn levelled_complexity(
+        &self,
+        _sum_size: u64,
+        _lwe_dimension: LweDimension,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        0.
+    }
+}
+
+#[allow(non_snake_case)]
+#[allow(dead_code)]
+fn algorithmic_complexity_pbs(n: f64, k: f64, N: f64, ell: f64) -> f64 {
+    n * (ell * (k + 1.) * N * (N.log2() + 1.)
+        + (k + 1.) * N * (N.log2() + 1.)
+        + N * ell * square(k + 1.))
+}
+
+#[allow(non_snake_case)]
+#[allow(dead_code)]
+fn algorithmic_complexity_ks(na: f64, nb: f64, ell: f64, log2_q: f64) -> f64 {
+    na * nb * ell * log2_q
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/mod.rs

@@ -0,0 +1,7 @@
+mod atomic_pattern;
+pub mod complexity;
+pub mod complexity_model;
+pub mod cpu;
+mod fft;
+pub mod gpu;
+pub mod operators;

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/operators/cmux.rs

@@ -0,0 +1,105 @@
+use super::super::complexity::Complexity;
+use super::super::fft;
+use crate::parameters::CmuxParameters;
+use crate::utils::square;
+
+#[derive(Clone)]
+pub struct SimpleWithFactors {
+    fft: fft::AsymptoticWithFactors,
+    blind_rotate_factor: f64,
+    constant_cost: f64, // global const
+}
+
+impl SimpleWithFactors {
+    pub fn fft_complexity(
+        &self,
+        glwe_polynomial_size: f64,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        self.fft.fft_complexity(glwe_polynomial_size) + glwe_polynomial_size
+    }
+
+    fn ifft_complexity(
+        &self,
+        glwe_polynomial_size: f64,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        self.fft.ifft_complexity(glwe_polynomial_size) + glwe_polynomial_size
+    }
+
+    // https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/bootstrap.py#L145
+    pub fn complexity(&self, params: CmuxParameters, ciphertext_modulus_log: u32) -> Complexity {
+        let glwe_polynomial_size = params.output_glwe_params.polynomial_size() as f64;
+
+        let f_glwe_size = (params.output_glwe_params.glwe_dimension + 1) as f64;
+        let br_decomposition_level_count = params.br_decomposition_parameter.level as f64;
+
+        let fft_cost = f_glwe_size
+            * br_decomposition_level_count
+            * self.fft_complexity(glwe_polynomial_size, ciphertext_modulus_log);
+
+        let ifft_cost =
+            f_glwe_size * self.ifft_complexity(glwe_polynomial_size, ciphertext_modulus_log);
+
+        let br_cost = square(f_glwe_size)
+            * br_decomposition_level_count
+            * glwe_polynomial_size
+            * self.blind_rotate_factor;
+
+        fft_cost + ifft_cost + br_cost + self.constant_cost
+    }
+}
+
+impl Default for SimpleWithFactors {
+    fn default() -> Self {
+        Self {
+            fft: fft::AsymptoticWithFactors::default(),
+            blind_rotate_factor: 1.0,
+            constant_cost: 0.0,
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use crate::parameters::{BrDecompositionParameters, GlweParameters};
+
+    use super::*;
+
+    #[test]
+    fn golden_python_prototype() {
+        let ignored = 0;
+        let golden = 8.0;
+
+        let cmux_param1 = CmuxParameters {
+            br_decomposition_parameter: BrDecompositionParameters {
+                level: 1,
+                log2_base: ignored,
+            },
+            output_glwe_params: GlweParameters {
+                log2_polynomial_size: 0,
+                glwe_dimension: 1,
+            },
+        };
+
+        let cmux_param2 = CmuxParameters {
+            br_decomposition_parameter: BrDecompositionParameters {
+                level: 300,
+                log2_base: ignored,
+            },
+            output_glwe_params: GlweParameters {
+                log2_polynomial_size: 0,
+                glwe_dimension: 20,
+            },
+        };
+
+        let comp = SimpleWithFactors::default();
+
+        let actual = comp.complexity(cmux_param1, 0);
+        approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON);
+
+        let golden = 138_621.0;
+        let actual = comp.complexity(cmux_param2, 64);
+        approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs

@@ -0,0 +1,51 @@
+use super::super::complexity::Complexity;
+use crate::parameters::KeyswitchParameters;
+
+#[derive(Clone)]
+pub struct KsComplexity;
+
+impl KsComplexity {
+    #[allow(clippy::cast_possible_wrap)]
+    pub fn complexity(
+        &self,
+        params: KeyswitchParameters,
+        _ciphertext_modulus_log: u32,
+    ) -> Complexity {
+        let _ = self;
+        // https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/keyswitch.py#L91
+        let input_lwe_dimension = params.input_lwe_dimension.0 as i64;
+        let output_lwe_dimension = params.output_lwe_dimension.0 as i64;
+        let level = params.ks_decomposition_parameter.level as i64;
+
+        let output_lwe_size = output_lwe_dimension + 1;
+        let count_decomposition = input_lwe_dimension * level;
+        let count_mul = input_lwe_dimension * level * output_lwe_size;
+        let count_add = (input_lwe_dimension * level - 1) * output_lwe_size + 1;
+        (count_decomposition + count_mul + count_add) as Complexity
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::parameters::{KsDecompositionParameters, LweDimension};
+
+    use super::*;
+
+    #[test]
+    fn golden_python_prototype() {
+        let ignored = 0;
+        let golden = 134_313_984.0;
+
+        let ks_params = KeyswitchParameters {
+            input_lwe_dimension: LweDimension(1024),
+            output_lwe_dimension: LweDimension(2048),
+            ks_decomposition_parameter: KsDecompositionParameters {
+                level: 32,
+                log2_base: ignored,
+            },
+        };
+
+        let actual = KsComplexity.complexity(ks_params, 64);
+        approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/operators/mod.rs

@@ -0,0 +1,3 @@
+pub mod cmux;
+pub(super) mod keyswitch_lwe;
+pub(super) mod pbs;

compilers/concrete-optimizer/concrete-optimizer/src/computing_cost/operators/pbs.rs

@@ -0,0 +1,65 @@
+use super::super::complexity::Complexity;
+use super::cmux;
+use crate::parameters::PbsParameters;
+
+#[derive(Default, Clone)]
+pub struct PbsComplexity {
+    pub cmux: cmux::SimpleWithFactors,
+}
+
+impl PbsComplexity {
+    pub fn complexity(&self, params: PbsParameters, ciphertext_modulus_log: u32) -> Complexity {
+        // https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/bootstrap.py#L163
+
+        let cmux_cost = self
+            .cmux
+            .complexity(params.cmux_parameters(), ciphertext_modulus_log);
+        (params.internal_lwe_dimension.0 as f64) * cmux_cost
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use crate::computing_cost::operators::pbs::PbsParameters;
+    use crate::parameters::{BrDecompositionParameters, GlweParameters, LweDimension};
+
+    #[test]
+    fn golden_python_prototype() {
+        let ignored = 0;
+        let golden = 8.0;
+
+        let pbs_param1 = PbsParameters {
+            internal_lwe_dimension: LweDimension(1),
+            br_decomposition_parameter: BrDecompositionParameters {
+                level: 1,
+                log2_base: ignored,
+            },
+            output_glwe_params: GlweParameters {
+                log2_polynomial_size: 0,
+                glwe_dimension: 1,
+            },
+        };
+
+        let pbs_param2 = PbsParameters {
+            internal_lwe_dimension: LweDimension(1024),
+            br_decomposition_parameter: BrDecompositionParameters {
+                level: 56,
+                log2_base: ignored,
+            },
+            output_glwe_params: GlweParameters {
+                log2_polynomial_size: 12,
+                glwe_dimension: 1024,
+            },
+        };
+
+        let complexity = PbsComplexity::default();
+
+        let actual = complexity.complexity(pbs_param1, 32);
+        approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON);
+
+        let golden = 249_957_554_585_600.0;
+        let actual = complexity.complexity(pbs_param2, 64);
+        approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/config.rs

@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::computing_cost::cpu::CpuComplexity;
+use crate::computing_cost::gpu::GpuComplexity;
+
+#[derive(Clone, Copy)]
+pub enum ProcessingUnit {
+    Cpu,
+    Gpu {
+        pbs_type: GpuPbsType,
+        number_of_sm: u64,
+    },
+}
+
+#[derive(Clone, Copy)]
+pub enum GpuPbsType {
+    Lowlat,
+    Amortized,
+}
+
+impl ProcessingUnit {
+    pub fn ks_to_string(self) -> &'static str {
+        match self {
+            Self::Cpu => "cpu",
+            Self::Gpu { .. } => "gpu",
+        }
+    }
+    pub fn br_to_string(self) -> &'static str {
+        match self {
+            Self::Cpu => "cpu",
+            Self::Gpu {
+                pbs_type: GpuPbsType::Lowlat,
+                ..
+            } => "gpu_lowlat",
+            Self::Gpu {
+                pbs_type: GpuPbsType::Amortized,
+                ..
+            } => "gpu_amortized",
+        }
+    }
+    pub fn complexity_model(self) -> Arc<dyn ComplexityModel> {
+        match self {
+            Self::Cpu => Arc::new(CpuComplexity::default()),
+            Self::Gpu {
+                pbs_type: GpuPbsType::Amortized,
+                number_of_sm,
+            } => Arc::new(GpuComplexity::default_amortized_u64(number_of_sm)),
+            Self::Gpu {
+                pbs_type: GpuPbsType::Lowlat,
+                number_of_sm,
+            } => Arc::new(GpuComplexity::default_lowlat_u64(number_of_sm)),
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/mod.rs

@@ -0,0 +1,3 @@
+pub mod operator;
+pub mod rewrite;
+pub mod unparametrized;

compilers/concrete-optimizer/concrete-optimizer/src/dag/operator/dot_kind.rs

@@ -0,0 +1,84 @@
+use super::{ClearTensor, Shape};
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum DotKind {
+    // inputs = [x,y,z], weights = [a,b,c], = x*a + y*b + z*c
+    Simple,
+    // inputs = [[x, y, z]], weights = [a,b,c], = same
+    Tensor,
+    // inputs = [[x], [y], [z]], weights = [[a],[b],[c]], = same
+    CompatibleTensor,
+    // inputs = [[x, y, z], [x, y, z]], weights = [[a,b,c]], = [same, same]
+    Broadcast,
+    Unsupported,
+}
+
+pub fn dot_kind<W>(nb_inputs: u64, input_shape: &Shape, weights: &ClearTensor<W>) -> DotKind {
+    let inputs_shape = Shape::duplicated(nb_inputs, input_shape);
+    if input_shape.is_number() && inputs_shape == weights.shape {
+        DotKind::Simple
+    } else if nb_inputs == 1 && *input_shape == weights.shape {
+        DotKind::Tensor
+    } else if inputs_shape == weights.shape {
+        DotKind::CompatibleTensor
+    } else if nb_inputs == 1 && input_shape.erase_first_dim() == weights.shape {
+        DotKind::Broadcast
+    } else {
+        DotKind::Unsupported
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dag::operator::{Shape, Weights};
+
+    #[test]
+    fn test_simple() {
+        assert_eq!(
+            dot_kind(2, &Shape::number(), &Weights::vector([1, 2])),
+            DotKind::Simple
+        );
+    }
+
+    #[test]
+    fn test_tensor() {
+        assert_eq!(
+            dot_kind(1, &Shape::vector(2), &Weights::vector([1, 2])),
+            DotKind::Tensor
+        );
+    }
+
+    #[test]
+    fn test_broadcast() {
+        let s2x2 = Shape {
+            dimensions_size: vec![2, 2],
+        };
+        assert_eq!(
+            dot_kind(1, &s2x2, &Weights::vector([1, 2])),
+            DotKind::Broadcast
+        );
+    }
+
+    #[test]
+    fn test_compatible() {
+        let weights = ClearTensor {
+            shape: Shape {
+                dimensions_size: vec![2, 1],
+            },
+            values: vec![1, 2],
+        };
+        assert_eq!(
+            dot_kind(2, &Shape::vector(1), &weights),
+            DotKind::CompatibleTensor
+        );
+    }
+
+    #[test]
+    fn test_unsupported() {
+        assert_eq!(
+            dot_kind(3, &Shape::number(), &Weights::vector([1, 2])),
+            DotKind::Unsupported
+        );
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/operator/mod.rs

@@ -0,0 +1,8 @@
+#![allow(clippy::module_inception)]
+pub mod dot_kind;
+pub mod operator;
+pub mod tensor;
+
+pub use self::dot_kind::*;
+pub use self::operator::*;
+pub use self::tensor::*;

compilers/concrete-optimizer/concrete-optimizer/src/dag/operator/operator.rs

@@ -0,0 +1,105 @@
+use crate::dag::operator::tensor::{ClearTensor, Shape};
+
+pub type Weights = ClearTensor<i64>;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FunctionTable {
+    pub values: Vec<u64>,
+}
+
+impl FunctionTable {
+    pub const UNKWOWN: Self = Self { values: vec![] };
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct LevelledComplexity {
+    pub lwe_dim_cost_factor: f64,
+    pub fixed_cost: f64,
+}
+
+impl LevelledComplexity {
+    pub const ZERO: Self = Self {
+        lwe_dim_cost_factor: 0.0,
+        fixed_cost: 0.0,
+    };
+    pub const ADDITION: Self = Self {
+        lwe_dim_cost_factor: 1.0,
+        fixed_cost: 0.0,
+    };
+}
+
+impl LevelledComplexity {
+    pub fn cost(&self, lwe_dimension: u64) -> f64 {
+        self.lwe_dim_cost_factor * (lwe_dimension as f64) + self.fixed_cost
+    }
+}
+
+impl std::ops::Add for LevelledComplexity {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            lwe_dim_cost_factor: self.lwe_dim_cost_factor + rhs.lwe_dim_cost_factor,
+            fixed_cost: self.fixed_cost + rhs.fixed_cost,
+        }
+    }
+}
+
+impl std::ops::AddAssign for LevelledComplexity {
+    fn add_assign(&mut self, rhs: Self) {
+        self.lwe_dim_cost_factor += rhs.lwe_dim_cost_factor;
+        self.fixed_cost += rhs.fixed_cost;
+    }
+}
+
+impl std::ops::Mul<u64> for LevelledComplexity {
+    type Output = Self;
+    fn mul(self, factor: u64) -> Self {
+        Self {
+            lwe_dim_cost_factor: self.lwe_dim_cost_factor * factor as f64,
+            fixed_cost: self.fixed_cost * factor as f64,
+        }
+    }
+}
+pub type Precision = u8;
+pub const MIN_PRECISION: Precision = 1;
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Operator {
+    Input {
+        out_precision: Precision,
+        out_shape: Shape,
+    },
+    Lut {
+        input: OperatorIndex,
+        table: FunctionTable,
+        out_precision: Precision,
+    },
+    Dot {
+        inputs: Vec<OperatorIndex>,
+        weights: Weights,
+    },
+    LevelledOp {
+        inputs: Vec<OperatorIndex>,
+        complexity: LevelledComplexity,
+        manp: f64,
+        out_shape: Shape,
+        comment: String,
+    },
+    // Used to reduced or increase precision when the cyphertext is compatible with different precision
+    // This is done without any checking
+    UnsafeCast {
+        input: OperatorIndex,
+        out_precision: Precision, // precision is changed without modifying the input, can be increase or decrease
+    },
+    // Round is expanded to sub-graph on direct representation or fused in lut for Radix and Crt representation.
+    Round {
+        input: OperatorIndex,
+        out_precision: Precision,
+    },
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct OperatorIndex {
+    pub i: usize,
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/operator/tensor.rs

@@ -0,0 +1,133 @@
+use std::iter::Sum;
+use std::ops::Mul;
+
+use crate::utils::square_ref;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Shape {
+    pub dimensions_size: Vec<u64>,
+}
+
+impl Shape {
+    pub fn first_dim_size(&self) -> u64 {
+        self.dimensions_size[0]
+    }
+
+    pub fn rank(&self) -> usize {
+        self.dimensions_size.len()
+    }
+
+    pub fn flat_size(&self) -> u64 {
+        let mut product = 1;
+        for dim_size in &self.dimensions_size {
+            product *= dim_size;
+        }
+        product
+    }
+
+    pub fn number() -> Self {
+        Self {
+            dimensions_size: vec![],
+        }
+    }
+
+    pub fn is_number(&self) -> bool {
+        self.rank() == 0
+    }
+
+    pub fn vector(size: u64) -> Self {
+        Self {
+            dimensions_size: vec![size],
+        }
+    }
+
+    pub fn is_vector(&self) -> bool {
+        self.rank() == 1
+    }
+
+    pub fn duplicated(out_dim_size: u64, other: &Self) -> Self {
+        let mut dimensions_size = Vec::with_capacity(other.rank() + 1);
+        dimensions_size.push(out_dim_size);
+        dimensions_size.extend_from_slice(&other.dimensions_size);
+        Self { dimensions_size }
+    }
+
+    pub fn erase_first_dim(&self) -> Self {
+        Self {
+            dimensions_size: self.dimensions_size[1..].to_vec(),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct ClearTensor<W> {
+    pub shape: Shape,
+    pub values: Vec<W>,
+}
+
+impl<W> ClearTensor<W>
+where
+    W: Copy + Mul<Output = W> + Sum<W>,
+{
+    pub fn number(value: W) -> Self {
+        Self {
+            shape: Shape::number(),
+            values: vec![value],
+        }
+    }
+
+    pub fn vector(values: impl Into<Vec<W>>) -> Self {
+        let values = values.into();
+        Self {
+            shape: Shape::vector(values.len() as u64),
+            values,
+        }
+    }
+
+    pub fn is_number(&self) -> bool {
+        self.shape.is_number()
+    }
+
+    pub fn is_vector(&self) -> bool {
+        self.shape.is_vector()
+    }
+
+    pub fn flat_size(&self) -> u64 {
+        self.shape.flat_size()
+    }
+
+    pub fn rank(&self) -> usize {
+        self.shape.rank()
+    }
+
+    pub fn square_norm2(&self) -> W {
+        self.values.iter().map(square_ref).sum()
+    }
+}
+
+// helps using shared shapes
+impl From<&Self> for Shape {
+    fn from(item: &Self) -> Self {
+        item.clone()
+    }
+}
+
+// helps using shared weights
+impl<W> From<&Self> for ClearTensor<W>
+where
+    W: Copy + Mul<Output = W> + Sum<W>,
+{
+    fn from(item: &Self) -> Self {
+        item.clone()
+    }
+}
+
+// helps using array as weights
+impl<const N: usize, W> From<[W; N]> for ClearTensor<W>
+where
+    W: Copy + Mul<Output = W> + Sum<W>,
+{
+    fn from(items: [W; N]) -> Self {
+        Self::vector(items)
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/rewrite/mod.rs

@@ -0,0 +1,2 @@
+pub mod regen;
+pub mod round;

compilers/concrete-optimizer/concrete-optimizer/src/dag/rewrite/regen.rs

@@ -0,0 +1,41 @@
+use crate::dag::operator::operator::Operator;
+use crate::dag::operator::OperatorIndex;
+use crate::dag::unparametrized::OperationDag;
+
+fn reindex_op_inputs(op: &Operator, old_index_to_new: &[usize]) -> Operator {
+    let mut op = op.clone();
+    match &mut op {
+        Operator::Input { .. } => (),
+        Operator::Lut { input, .. }
+        | Operator::UnsafeCast { input, .. }
+        | Operator::Round { input, .. } => input.i = old_index_to_new[input.i],
+        Operator::Dot { inputs, .. } | Operator::LevelledOp { inputs, .. } => {
+            for input in inputs {
+                input.i = old_index_to_new[input.i];
+            }
+        }
+    };
+    op
+}
+
+pub(crate) fn regen(
+    dag: &OperationDag,
+    f: &mut dyn FnMut(usize, &Operator, &mut OperationDag) -> Option<OperatorIndex>,
+) -> OperationDag {
+    let mut regen_dag = OperationDag::new();
+    let mut old_index_to_new = vec![];
+    for (i, op) in dag.operators.iter().enumerate() {
+        let op = reindex_op_inputs(op, &old_index_to_new);
+        let size = regen_dag.operators.len();
+        if let Some(op_i) = f(i, &op, &mut regen_dag) {
+            old_index_to_new.push(op_i.i);
+        } else {
+            assert!(size == regen_dag.operators.len());
+            old_index_to_new.push(regen_dag.len());
+            regen_dag.operators.push(op.clone());
+            regen_dag.out_precisions.push(dag.out_precisions[i]);
+            regen_dag.out_shapes.push(dag.out_shapes[i].clone());
+        }
+    }
+    regen_dag
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/rewrite/round.rs

@@ -0,0 +1,18 @@
+use crate::dag::operator::{Operator, OperatorIndex};
+use crate::dag::unparametrized::OperationDag;
+
+use super::regen::regen;
+
+fn regen_round(_: usize, op: &Operator, dag: &mut OperationDag) -> Option<OperatorIndex> {
+    match *op {
+        Operator::Round {
+            input,
+            out_precision,
+        } => Some(dag.add_expanded_round(input, out_precision)),
+        _ => None,
+    }
+}
+
+pub(crate) fn expand_round(dag: &OperationDag) -> OperationDag {
+    regen(dag, &mut regen_round)
+}

compilers/concrete-optimizer/concrete-optimizer/src/dag/unparametrized.rs

@@ -0,0 +1,464 @@
+use std::fmt::Write;
+
+use crate::dag::operator::{
+    dot_kind, DotKind, FunctionTable, LevelledComplexity, Operator, OperatorIndex, Precision,
+    Shape, Weights,
+};
+
+pub(crate) type UnparameterizedOperator = Operator;
+
+#[derive(Clone, PartialEq, Debug)]
+#[must_use]
+pub struct OperationDag {
+    pub(crate) operators: Vec<UnparameterizedOperator>,
+    // Collect all operators ouput shape
+    pub(crate) out_shapes: Vec<Shape>,
+    // Collect all operators ouput precision
+    pub(crate) out_precisions: Vec<Precision>,
+}
+
+impl OperationDag {
+    pub const fn new() -> Self {
+        Self {
+            operators: vec![],
+            out_shapes: vec![],
+            out_precisions: vec![],
+        }
+    }
+
+    fn add_operator(&mut self, operator: UnparameterizedOperator) -> OperatorIndex {
+        let i = self.operators.len();
+        self.out_precisions
+            .push(self.infer_out_precision(&operator));
+        self.out_shapes.push(self.infer_out_shape(&operator));
+        self.operators.push(operator);
+        OperatorIndex { i }
+    }
+
+    pub fn add_input(
+        &mut self,
+        out_precision: Precision,
+        out_shape: impl Into<Shape>,
+    ) -> OperatorIndex {
+        let out_shape = out_shape.into();
+        self.add_operator(Operator::Input {
+            out_precision,
+            out_shape,
+        })
+    }
+
+    pub fn add_lut(
+        &mut self,
+        input: OperatorIndex,
+        table: FunctionTable,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        self.add_operator(Operator::Lut {
+            input,
+            table,
+            out_precision,
+        })
+    }
+
+    pub fn add_dot(
+        &mut self,
+        inputs: impl Into<Vec<OperatorIndex>>,
+        weights: impl Into<Weights>,
+    ) -> OperatorIndex {
+        let inputs = inputs.into();
+        let weights = weights.into();
+        self.add_operator(Operator::Dot { inputs, weights })
+    }
+
+    pub fn add_levelled_op(
+        &mut self,
+        inputs: impl Into<Vec<OperatorIndex>>,
+        complexity: LevelledComplexity,
+        manp: f64,
+        out_shape: impl Into<Shape>,
+        comment: impl Into<String>,
+    ) -> OperatorIndex {
+        let inputs = inputs.into();
+        let out_shape = out_shape.into();
+        let comment = comment.into();
+        let op = Operator::LevelledOp {
+            inputs,
+            complexity,
+            manp,
+            out_shape,
+            comment,
+        };
+        self.add_operator(op)
+    }
+
+    pub fn add_unsafe_cast(
+        &mut self,
+        input: OperatorIndex,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        let input_precision = self.out_precisions[input.i];
+        if input_precision == out_precision {
+            return input;
+        }
+        self.add_operator(Operator::UnsafeCast {
+            input,
+            out_precision,
+        })
+    }
+
+    pub fn add_round_op(
+        &mut self,
+        input: OperatorIndex,
+        rounded_precision: Precision,
+    ) -> OperatorIndex {
+        let in_precision = self.out_precisions[input.i];
+        assert!(rounded_precision <= in_precision);
+        self.add_operator(Operator::Round {
+            input,
+            out_precision: rounded_precision,
+        })
+    }
+
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.operators.len()
+    }
+
+    pub fn dump(&self) -> String {
+        let mut acc = String::new();
+        let err_msg = "Optimizer: Can't dump OperationDag";
+        writeln!(acc, "Dag:").expect(err_msg);
+        for (i, op) in self.operators.iter().enumerate() {
+            writeln!(acc, "%{i} <- {op:?}").expect(err_msg);
+        }
+        acc
+    }
+
+    fn add_shift_left_lsb_to_msb_no_padding(&mut self, input: OperatorIndex) -> OperatorIndex {
+        // Convert any input to simple 1bit msb replacing the padding
+        // For now encoding is not explicit, so 1 bit content without padding <=> 0 bit content with padding.
+        let in_precision = self.out_precisions[input.i];
+        let shift_factor = Weights::number(1 << (in_precision as i64));
+        let lsb_as_msb = self.add_dot([input], shift_factor);
+        self.add_unsafe_cast(lsb_as_msb, 0 as Precision)
+    }
+
+    fn add_lut_1bit_no_padding(
+        &mut self,
+        input: OperatorIndex,
+        table: FunctionTable,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        // For now encoding is not explicit, so 1 bit content without padding <=> 0 bit content with padding.
+        let in_precision = self.out_precisions[input.i];
+        assert!(in_precision == 0);
+        // An add after with a clear constant is skipped here as it doesn't change noise handling.
+        self.add_lut(input, table, out_precision)
+    }
+
+    fn add_shift_right_msb_no_padding_to_lsb(
+        &mut self,
+        input: OperatorIndex,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        // Convert simple 1 bit msb to a nbit with zero padding
+        let to_nbits_padded = FunctionTable::UNKWOWN;
+        self.add_lut_1bit_no_padding(input, to_nbits_padded, out_precision)
+    }
+
+    fn add_isolate_lowest_bit(&mut self, input: OperatorIndex) -> OperatorIndex {
+        // The lowest bit is converted to a cyphertext of same precision as input.
+        // Introduce a pbs of input precision but this precision is only used on 1 levelled op and converted to lower precision
+        // Noise is reduced by a pbs.
+        let out_precision = self.out_precisions[input.i];
+        let lsb_as_msb = self.add_shift_left_lsb_to_msb_no_padding(input);
+        self.add_shift_right_msb_no_padding_to_lsb(lsb_as_msb, out_precision)
+    }
+
+    pub fn add_truncate_1_bit(&mut self, input: OperatorIndex) -> OperatorIndex {
+        // Reset a bit.
+        // ex: 10110 is truncated to 1011, 10111 is truncated to 1011
+        let in_precision = self.out_precisions[input.i];
+        let lowest_bit = self.add_isolate_lowest_bit(input);
+        let bit_cleared = self.add_dot([input, lowest_bit], [1, -1]);
+        self.add_unsafe_cast(bit_cleared, in_precision - 1)
+    }
+
+    pub fn add_expanded_round(
+        &mut self,
+        input: OperatorIndex,
+        rounded_precision: Precision,
+    ) -> OperatorIndex {
+        // Round such that the ouput has precision out_precision.
+        // We round by adding 2**(removed_precision - 1) to the last remaining bit to clear (this step is a no-op).
+        // Than all lower bits are cleared.
+        // Note: this is a simplified graph, some constant additions are missing without consequence on crypto parameter choice.
+        // Note: reset and rounds could be done by 4, 3, 2 and 1 bits groups for efficiency.
+        //       bit efficiency is better for 4 precision then 3, but the feasability is lower for high noise
+        let in_precision = self.out_precisions[input.i];
+        assert!(rounded_precision <= in_precision);
+        if in_precision == rounded_precision {
+            return input;
+        }
+        // Add rounding constant, this is a represented as non-op since it doesn't influence crypto parameters.
+        let mut rounded = input;
+        // The rounded is in high precision with garbage lowest bits
+        let bits_to_truncate = in_precision - rounded_precision;
+        for _ in 1..=bits_to_truncate as i64 {
+            rounded = self.add_truncate_1_bit(rounded);
+        }
+        rounded
+    }
+
+    pub fn add_expanded_rounded_lut(
+        &mut self,
+        input: OperatorIndex,
+        table: FunctionTable,
+        rounded_precision: Precision,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        // note: this is a simplified graph, some constant additions are missing without consequence on crypto parameter choice.
+        let rounded = self.add_expanded_round(input, rounded_precision);
+        self.add_lut(rounded, table, out_precision)
+    }
+
+    pub fn add_rounded_lut(
+        &mut self,
+        input: OperatorIndex,
+        table: FunctionTable,
+        rounded_precision: Precision,
+        out_precision: Precision,
+    ) -> OperatorIndex {
+        let rounded = self.add_round_op(input, rounded_precision);
+        self.add_lut(rounded, table, out_precision)
+    }
+
+    fn infer_out_shape(&self, op: &UnparameterizedOperator) -> Shape {
+        match op {
+            Operator::Input { out_shape, .. } | Operator::LevelledOp { out_shape, .. } => {
+                out_shape.clone()
+            }
+            Operator::Lut { input, .. }
+            | Operator::UnsafeCast { input, .. }
+            | Operator::Round { input, .. } => self.out_shapes[input.i].clone(),
+            Operator::Dot {
+                inputs, weights, ..
+            } => {
+                let input_shape = self.out_shapes[inputs[0].i].clone();
+                let kind = dot_kind(inputs.len() as u64, &input_shape, weights);
+                match kind {
+                    DotKind::Simple | DotKind::Tensor | DotKind::CompatibleTensor => {
+                        Shape::number()
+                    }
+                    DotKind::Broadcast { .. } => Shape::vector(input_shape.first_dim_size()),
+                    DotKind::Unsupported { .. } => {
+                        let weights_shape = &weights.shape;
+                        println!();
+                        println!();
+                        println!("Error diagnostic on dot operation:");
+                        println!(
+                            "Incompatible operands: <{input_shape:?}> DOT <{weights_shape:?}>"
+                        );
+                        println!();
+                        panic!("Unsupported or invalid dot operation")
+                    }
+                }
+            }
+        }
+    }
+
+    fn infer_out_precision(&self, op: &UnparameterizedOperator) -> Precision {
+        match op {
+            Operator::Input { out_precision, .. }
+            | Operator::Lut { out_precision, .. }
+            | Operator::UnsafeCast { out_precision, .. }
+            | Operator::Round { out_precision, .. } => *out_precision,
+            Operator::Dot { inputs, .. } | Operator::LevelledOp { inputs, .. } => {
+                self.out_precisions[inputs[0].i]
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dag::operator::Shape;
+
+    #[test]
+    fn graph_creation() {
+        let mut graph = OperationDag::new();
+
+        let input1 = graph.add_input(1, Shape::number());
+
+        let input2 = graph.add_input(2, Shape::number());
+
+        let cpx_add = LevelledComplexity::ADDITION;
+        let sum1 = graph.add_levelled_op([input1, input2], cpx_add, 1.0, Shape::number(), "sum");
+
+        let lut1 = graph.add_lut(sum1, FunctionTable::UNKWOWN, 1);
+
+        let concat =
+            graph.add_levelled_op([input1, lut1], cpx_add, 1.0, Shape::vector(2), "concat");
+
+        let dot = graph.add_dot([concat], [1, 2]);
+
+        let lut2 = graph.add_lut(dot, FunctionTable::UNKWOWN, 2);
+
+        let ops_index = [input1, input2, sum1, lut1, concat, dot, lut2];
+        for (expected_i, op_index) in ops_index.iter().enumerate() {
+            assert_eq!(expected_i, op_index.i);
+        }
+
+        assert_eq!(
+            graph.operators,
+            vec![
+                Operator::Input {
+                    out_precision: 1,
+                    out_shape: Shape::number(),
+                },
+                Operator::Input {
+                    out_precision: 2,
+                    out_shape: Shape::number(),
+                },
+                Operator::LevelledOp {
+                    inputs: vec![input1, input2],
+                    complexity: cpx_add,
+                    manp: 1.0,
+                    out_shape: Shape::number(),
+                    comment: "sum".to_string(),
+                },
+                Operator::Lut {
+                    input: sum1,
+                    table: FunctionTable::UNKWOWN,
+                    out_precision: 1,
+                },
+                Operator::LevelledOp {
+                    inputs: vec![input1, lut1],
+                    complexity: cpx_add,
+                    manp: 1.0,
+                    out_shape: Shape::vector(2),
+                    comment: "concat".to_string(),
+                },
+                Operator::Dot {
+                    inputs: vec![concat],
+                    weights: Weights {
+                        shape: Shape::vector(2),
+                        values: vec![1, 2]
+                    },
+                },
+                Operator::Lut {
+                    input: dot,
+                    table: FunctionTable::UNKWOWN,
+                    out_precision: 2,
+                }
+            ]
+        );
+    }
+
+    #[test]
+    fn test_rounded_lut() {
+        let mut graph = OperationDag::new();
+        let out_precision = 5;
+        let rounded_precision = 2;
+        let input1 = graph.add_input(out_precision, Shape::number());
+        let _ = graph.add_expanded_rounded_lut(
+            input1,
+            FunctionTable::UNKWOWN,
+            rounded_precision,
+            out_precision,
+        );
+        let expecteds = [
+            Operator::Input {
+                out_precision,
+                out_shape: Shape::number(),
+            },
+            // The rounding addition skipped, it's a no-op wrt crypto parameter
+            // Clear: cleared = input - bit0
+            //// Extract bit
+            Operator::Dot {
+                inputs: vec![input1],
+                weights: Weights::number(1 << 5),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 1 },
+                out_precision: 0,
+            },
+            //// 1 Bit to out_precision
+            Operator::Lut {
+                input: OperatorIndex { i: 2 },
+                table: FunctionTable::UNKWOWN,
+                out_precision: 5,
+            },
+            //// Erase bit
+            Operator::Dot {
+                inputs: vec![input1, OperatorIndex { i: 3 }],
+                weights: Weights::vector([1, -1]),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 4 },
+                out_precision: 4,
+            },
+            // Clear: cleared = input - bit0 - bit1
+            //// Extract bit
+            Operator::Dot {
+                inputs: vec![OperatorIndex { i: 5 }],
+                weights: Weights::number(1 << 4),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 6 },
+                out_precision: 0,
+            },
+            //// 1 Bit to out_precision
+            Operator::Lut {
+                input: OperatorIndex { i: 7 },
+                table: FunctionTable::UNKWOWN,
+                out_precision: 4,
+            },
+            //// Erase bit
+            Operator::Dot {
+                inputs: vec![OperatorIndex { i: 5 }, OperatorIndex { i: 8 }],
+                weights: Weights::vector([1, -1]),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 9 },
+                out_precision: 3,
+            },
+            // Clear: cleared = input - bit0 - bit1 - bit2
+            //// Extract bit
+            Operator::Dot {
+                inputs: vec![OperatorIndex { i: 10 }],
+                weights: Weights::number(1 << 3),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 11 },
+                out_precision: 0,
+            },
+            //// 1 Bit to out_precision
+            Operator::Lut {
+                input: OperatorIndex { i: 12 },
+                table: FunctionTable::UNKWOWN,
+                out_precision: 3,
+            },
+            //// Erase bit
+            Operator::Dot {
+                inputs: vec![OperatorIndex { i: 10 }, OperatorIndex { i: 13 }],
+                weights: Weights::vector([1, -1]),
+            },
+            Operator::UnsafeCast {
+                input: OperatorIndex { i: 14 },
+                out_precision: 2,
+            },
+            // Lut on rounded precision
+            Operator::Lut {
+                input: OperatorIndex { i: 15 },
+                table: FunctionTable::UNKWOWN,
+                out_precision: 5,
+            },
+        ];
+        assert_eq!(expecteds.len(), graph.operators.len());
+        for (i, (expected, actual)) in std::iter::zip(expecteds, graph.operators).enumerate() {
+            assert_eq!(expected, actual, "{i}-th operation");
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/global_parameters.rs

@@ -0,0 +1,64 @@
+use crate::parameters::{
+    BrDecompositionParameterRanges, GlweParameterRanges, KsDecompositionParameterRanges,
+};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+struct ParameterCount {
+    pub glwe: usize,
+    pub br_decomposition: usize,
+    pub ks_decomposition: usize,
+}
+
+#[derive(Clone, Copy)]
+pub struct ParameterDomains {
+    // move next comment to pareto ranges definition
+    // TODO: verify if pareto optimal parameters depends on precisions
+    pub glwe_pbs_constrained: GlweParameterRanges,
+    pub free_glwe: GlweParameterRanges,
+    pub br_decomposition: BrDecompositionParameterRanges,
+    pub ks_decomposition: KsDecompositionParameterRanges,
+}
+
+pub const DEFAUT_DOMAINS: ParameterDomains = ParameterDomains {
+    glwe_pbs_constrained: GlweParameterRanges {
+        log2_polynomial_size: Range { start: 8, end: 18 },
+        glwe_dimension: Range { start: 1, end: 7 },
+    },
+    free_glwe: GlweParameterRanges {
+        log2_polynomial_size: Range { start: 0, end: 1 },
+        glwe_dimension: Range {
+            start: 512,
+            end: 2048,
+        },
+    },
+    br_decomposition: BrDecompositionParameterRanges {
+        log2_base: Range { start: 1, end: 65 },
+        level: Range { start: 1, end: 65 },
+    },
+    ks_decomposition: KsDecompositionParameterRanges {
+        log2_base: Range { start: 1, end: 65 },
+        level: Range { start: 1, end: 65 },
+    },
+};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Range {
+    pub start: u64,
+    pub end: u64,
+}
+
+impl IntoIterator for &Range {
+    type Item = u64;
+
+    type IntoIter = std::ops::Range<u64>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.start..self.end
+    }
+}
+
+impl Range {
+    pub fn as_vec(self) -> Vec<u64> {
+        self.into_iter().collect()
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/lib.rs

@@ -0,0 +1,30 @@
+#![warn(clippy::nursery)]
+#![warn(clippy::pedantic)]
+#![warn(clippy::style)]
+#![allow(clippy::cast_lossless)]
+#![allow(clippy::cast_precision_loss)] // u64 to f64
+#![allow(clippy::cast_possible_truncation)] // u64 to usize
+#![allow(clippy::match_wildcard_for_single_variants)]
+#![allow(clippy::manual_range_contains)]
+#![allow(clippy::missing_panics_doc)]
+#![allow(clippy::missing_const_for_fn)]
+#![allow(clippy::module_name_repetitions)]
+#![allow(clippy::must_use_candidate)]
+#![allow(clippy::return_self_not_must_use)]
+#![allow(clippy::similar_names)]
+#![allow(clippy::suboptimal_flops)]
+#![allow(clippy::too_many_arguments)]
+#![warn(unused_results)]
+
+pub mod computing_cost;
+
+pub mod config;
+pub mod dag;
+pub mod global_parameters;
+pub mod noise_estimator;
+pub mod optimization;
+pub mod parameters;
+pub mod utils;
+pub mod weight;
+
+pub use concrete_security_curves::gaussian::security::supported_security_levels;

compilers/concrete-optimizer/concrete-optimizer/src/noise_estimator/error.rs

@@ -0,0 +1,95 @@
+use concrete_cpu_noise_model::gaussian_noise::conversion::modular_variance_to_variance;
+
+use crate::utils::square;
+
+pub fn sigma_scale_of_error_probability(p_error: f64) -> f64 {
+    // https://en.wikipedia.org/wiki/Error_function#Applications
+    puruspe::inverfc(p_error) * 2_f64.sqrt()
+}
+
+pub fn error_probability_of_sigma_scale(sigma_scale: f64) -> f64 {
+    puruspe::erfc(sigma_scale / 2_f64.sqrt())
+}
+
+const LEFT_PADDING_BITS: u64 = 1;
+const RIGHT_PADDING_BITS: u64 = 1;
+
+pub fn fatal_variance_limit(padding_bits: u64, precision: u64, ciphertext_modulus_log: u32) -> f64 {
+    let no_noise_bits = padding_bits + precision;
+    let noise_bits: i64 = ciphertext_modulus_log as i64 - i64::try_from(no_noise_bits).unwrap();
+    2_f64.powi(noise_bits as i32)
+}
+
+fn safe_variance_bound_from_p_error(
+    fatal_noise_limit: f64,
+    ciphertext_modulus_log: u32,
+    maximum_acceptable_error_probability: f64,
+) -> f64 {
+    // We want safe_sigma such that:
+    // P(x not in [-+fatal_noise_limit] | σ = safe_sigma) = p_error
+    // <=> P(x not in [-+fatal_noise_limit/safe_sigma] | σ = 1) = p_error
+    // <=> P(x not in [-+kappa] | σ = 1) = p_error, with safe_sigma = fatal_noise_limit / kappa
+    let kappa = sigma_scale_of_error_probability(maximum_acceptable_error_probability);
+    let safe_sigma = fatal_noise_limit / kappa;
+    let modular_variance = square(safe_sigma);
+
+    modular_variance_to_variance(modular_variance, ciphertext_modulus_log)
+}
+
+pub fn safe_variance_bound_2padbits(
+    precision: u64,
+    ciphertext_modulus_log: u32,
+    maximum_acceptable_error_probability: f64,
+) -> f64 {
+    let padding_bits = LEFT_PADDING_BITS + RIGHT_PADDING_BITS;
+    let fatal_noise_limit = fatal_variance_limit(padding_bits, precision, ciphertext_modulus_log);
+    safe_variance_bound_from_p_error(
+        fatal_noise_limit,
+        ciphertext_modulus_log,
+        maximum_acceptable_error_probability,
+    )
+}
+
+pub fn safe_variance_bound_product_1padbit(
+    precision: u64,
+    ciphertext_modulus_log: u32,
+    maximum_acceptable_error_probability: f64,
+) -> f64 {
+    let noise_bits = ciphertext_modulus_log as u64 - precision - 2;
+    let fatal_noise_limit = 2_f64.powi(noise_bits as i32);
+    safe_variance_bound_from_p_error(
+        fatal_noise_limit,
+        ciphertext_modulus_log,
+        maximum_acceptable_error_probability,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_sigmas() {
+        // https://en.wikipedia.org/wiki/Normal_distribution#Standard_deviation_and_coverage
+        let reference = &[
+            0.682_689_492_137, // +- 1 sigma
+            0.954_499_736_104, // 2
+            0.997_300_203_937, // ...
+            0.999_936_657_516,
+            0.999_999_426_697,
+        ];
+        for (i, &p_in) in reference.iter().enumerate() {
+            let p_out = 1.0 - p_in;
+            let expected_scale = (i + 1) as f64;
+            approx::assert_relative_eq!(
+                expected_scale,
+                sigma_scale_of_error_probability(p_out),
+                max_relative = 1e-8
+            );
+            approx::assert_relative_eq!(
+                p_out,
+                error_probability_of_sigma_scale(sigma_scale_of_error_probability(p_out)),
+                max_relative = 1e-8
+            );
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/noise_estimator/mod.rs

@@ -0,0 +1,3 @@
+pub mod error;
+pub mod operators;
+pub mod p_error;

compilers/concrete-optimizer/concrete-optimizer/src/noise_estimator/operators/atomic_pattern.rs

@@ -0,0 +1,29 @@
+use crate::parameters::AtomicPatternParameters;
+use concrete_cpu_noise_model::gaussian_noise::noise::keyswitch::variance_keyswitch;
+use concrete_cpu_noise_model::gaussian_noise::noise::modulus_switching::estimate_modulus_switching_noise_with_binary_key;
+use concrete_security_curves::gaussian::security::minimal_variance_lwe;
+
+pub fn maximal_noise(
+    input_variance: f64,
+    param: AtomicPatternParameters,
+    ciphertext_modulus_log: u32, //log(q)
+    security_level: u64,
+) -> f64 {
+    let v_keyswitch = variance_keyswitch(
+        param.input_lwe_dimension.0,
+        param.ks_decomposition_parameter.log2_base,
+        param.ks_decomposition_parameter.level,
+        ciphertext_modulus_log,
+        minimal_variance_lwe(
+            param.internal_lwe_dimension.0,
+            ciphertext_modulus_log,
+            security_level,
+        ),
+    );
+    let v_modulus_switch = estimate_modulus_switching_noise_with_binary_key(
+        param.internal_lwe_dimension.0,
+        param.output_glwe_params.log2_polynomial_size,
+        ciphertext_modulus_log,
+    );
+    input_variance + v_keyswitch + v_modulus_switch
+}

compilers/concrete-optimizer/concrete-optimizer/src/noise_estimator/operators/mod.rs

@@ -0,0 +1 @@
+pub mod atomic_pattern;

compilers/concrete-optimizer/concrete-optimizer/src/noise_estimator/p_error.rs

@@ -0,0 +1,79 @@
+pub fn combine_errors(p_error1: f64, p_error2: f64) -> f64 {
+    // (1 - p_error) = (1 - p_error1) * (1 - p_error2)
+    p_error1 + p_error2 - p_error1 * p_error2
+}
+
+pub fn repeat_p_error(p_error: f64, count: u64) -> f64 {
+    if p_error * count as f64 > 1. {
+        iterative_repeat_p_error(p_error, count)
+    } else {
+        binomial_decomposition_repeat_p_error(p_error, count)
+    }
+}
+
+// (1 - global_p_error) = (1 - p_error)^count
+// global_p_error = 1 - (1-p)^N = 1 - (1 - N p + N(N-1)/2 p^2 - N(N-1)(N-2)/(2*3) p^3...)
+// global_p_error = N p - N(N-1)/2 p^2 + N(N-1)(N-2)/(2*3) p^3...
+fn binomial_decomposition_repeat_p_error(p_error: f64, count: u64) -> f64 {
+    // This guarantees abs(factor) is decreasing
+    // Without that, factors grow and lose precision
+    assert!(p_error * (count as f64) <= 1.0);
+
+    let mut global_p_error = 0.0;
+
+    let mut factor = -1.0;
+
+    for i in 1..=count {
+        factor *= -p_error * (count - i + 1) as f64 / i as f64;
+
+        let new_global_p_error = global_p_error + factor;
+
+        #[allow(clippy::float_cmp)]
+        //if factor is too small to make a difference
+        if new_global_p_error == global_p_error {
+            // abs(factor) is decreasing and factor sign alternates
+            // so the remaining series is bounded (in absolute value) by abs(factor) which makes no difference
+            break;
+        }
+
+        global_p_error = new_global_p_error;
+    }
+
+    global_p_error
+}
+
+fn iterative_repeat_p_error(p_error: f64, count: u64) -> f64 {
+    let mut global_p_error = 0.0;
+
+    for _ in 0..count {
+        global_p_error = combine_errors(global_p_error, p_error);
+    }
+
+    global_p_error
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[allow(clippy::float_cmp)]
+    fn assert_eq_both_repeat_p_error(p_error: f64, count: u64) {
+        let iterative = iterative_repeat_p_error(p_error, count);
+        let binomial = binomial_decomposition_repeat_p_error(p_error, count);
+
+        assert!(((iterative - binomial) / (iterative + binomial)).abs() < 0.000_000_1);
+    }
+
+    #[test]
+    #[allow(clippy::float_cmp)]
+    fn test_repeat_p_error() {
+        assert_eq!(repeat_p_error(0.5, 1), 0.5);
+        assert_eq!(repeat_p_error(0.5, 2), 0.75);
+
+        assert_eq_both_repeat_p_error(0.00001, 10000);
+
+        assert_eq_both_repeat_p_error(0.001, 100);
+
+        assert_eq_both_repeat_p_error(0.000_000_000_01, 100);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/atomic_pattern.rs

@@ -0,0 +1,232 @@
+use concrete_cpu_noise_model::gaussian_noise::noise::modulus_switching::estimate_modulus_switching_noise_with_binary_key;
+
+use super::config::{Config, SearchSpace};
+use super::decomposition::cmux::CmuxComplexityNoise;
+use super::decomposition::keyswitch::KsComplexityNoise;
+use super::wop_atomic_pattern::optimize::find_p_error;
+use crate::noise_estimator::error;
+use crate::parameters::{BrDecompositionParameters, GlweParameters, KsDecompositionParameters};
+use crate::utils::square;
+
+use super::decomposition::{circuit_bootstrap, cmux, keyswitch, pp_switch, PersistDecompCaches};
+
+// Ref time for v0 table 1 thread: 950ms
+const CUTS: bool = true; // 80ms
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Solution {
+    pub input_lwe_dimension: u64,              //n_big
+    pub internal_ks_output_lwe_dimension: u64, //n_small
+    pub ks_decomposition_level_count: u64,     //l(KS)
+    pub ks_decomposition_base_log: u64,        //b(KS)
+    pub glwe_polynomial_size: u64,             //N
+    pub glwe_dimension: u64,                   //k
+    pub br_decomposition_level_count: u64,     //l(BR)
+    pub br_decomposition_base_log: u64,        //b(BR)
+    pub complexity: f64,
+    pub noise_max: f64,
+    pub p_error: f64, // error probability
+    pub global_p_error: f64,
+}
+
+// Constants during optimisation of decompositions
+pub(crate) struct OptimizationDecompositionsConsts<'a> {
+    pub config: Config<'a>,
+    pub kappa: f64,
+    pub sum_size: u64,
+    pub noise_factor: f64,
+    pub safe_variance: f64,
+}
+
+pub struct OptimizationState {
+    pub best_solution: Option<Solution>,
+}
+
+pub struct Caches {
+    pub cmux: cmux::Cache,
+    pub keyswitch: keyswitch::Cache,
+    pub pp_switch: pp_switch::Cache,
+    pub cb_pbs: circuit_bootstrap::Cache,
+}
+
+#[allow(clippy::too_many_lines)]
+fn update_state_with_best_decompositions(
+    state: &mut OptimizationState,
+    consts: &OptimizationDecompositionsConsts,
+    internal_dim: u64,
+    glwe_params: GlweParameters,
+    cmux_quantities: &[CmuxComplexityNoise],
+    ks_quantities: &[KsComplexityNoise],
+) {
+    let input_lwe_dimension = glwe_params.sample_extract_lwe_dimension();
+    let noise_modulus_switching = estimate_modulus_switching_noise_with_binary_key(
+        internal_dim,
+        glwe_params.log2_polynomial_size,
+        consts.config.ciphertext_modulus_log,
+    );
+    let safe_variance = consts.safe_variance;
+    if CUTS && noise_modulus_switching > safe_variance {
+        return;
+    }
+
+    let mut best_complexity = state.best_solution.map_or(f64::INFINITY, |s| s.complexity);
+    let mut best_variance = state.best_solution.map_or(f64::INFINITY, |s| s.noise_max);
+
+    let complexity_multisum = (consts.sum_size * input_lwe_dimension) as f64;
+
+    let square_noise_factor = square(consts.noise_factor);
+    for cmux_quantity in cmux_quantities {
+        // increasing complexity, decreasing variance
+        let noise_in = cmux_quantity.noise_br(internal_dim) * square_noise_factor;
+        let noise_max = noise_in + noise_modulus_switching;
+        if noise_max > safe_variance && CUTS {
+            continue;
+        }
+        let complexity_pbs = cmux_quantity.complexity_br(internal_dim);
+        let complexity = complexity_multisum + complexity_pbs;
+        if complexity > best_complexity {
+            // As best can evolves it is complementary to blind_rotate_quantities cuts.
+            break;
+        }
+        for &ks_quantity in ks_quantities.iter().rev() {
+            let complexity_keyswitch = ks_quantity.complexity(input_lwe_dimension);
+            let complexity = complexity_multisum + complexity_keyswitch + complexity_pbs;
+            if complexity > best_complexity {
+                continue;
+            }
+            // increasing variance, decreasing complexity
+            let noise_keyswitch = ks_quantity.noise(input_lwe_dimension);
+            let noise_max = noise_in + noise_keyswitch + noise_modulus_switching;
+            if noise_max > safe_variance {
+                // increasing variance => we can skip all remaining
+                break;
+            }
+            // feasible and at least as good complexity
+            if complexity < best_complexity || noise_max < best_variance {
+                let p_error = find_p_error(consts.kappa, safe_variance, noise_max);
+
+                let BrDecompositionParameters {
+                    level: br_l,
+                    log2_base: br_b,
+                } = cmux_quantity.decomp;
+                let KsDecompositionParameters {
+                    level: ks_l,
+                    log2_base: ks_b,
+                } = ks_quantity.decomp;
+
+                best_complexity = complexity;
+                best_variance = noise_max;
+                state.best_solution = Some(Solution {
+                    input_lwe_dimension,
+                    internal_ks_output_lwe_dimension: internal_dim,
+                    ks_decomposition_level_count: ks_l,
+                    ks_decomposition_base_log: ks_b,
+                    glwe_polynomial_size: glwe_params.polynomial_size(),
+                    glwe_dimension: glwe_params.glwe_dimension,
+                    br_decomposition_level_count: br_l,
+                    br_decomposition_base_log: br_b,
+                    noise_max,
+                    complexity,
+                    p_error,
+                    global_p_error: f64::NAN,
+                });
+            }
+        }
+    } // br ks
+}
+
+const REL_EPSILON_PROBA: f64 = 1.0 + 1e-8;
+
+pub fn optimize_one(
+    sum_size: u64,
+    precision: u64,
+    config: Config,
+    noise_factor: f64,
+    search_space: &SearchSpace,
+    persistent_caches: &PersistDecompCaches,
+) -> OptimizationState {
+    assert!(0 < precision);
+    assert!(1.0 <= noise_factor);
+    assert!(0.0 < config.maximum_acceptable_error_probability);
+    assert!(config.maximum_acceptable_error_probability < 1.0);
+
+    // this assumed the noise level is equal at input/output
+    // the security of the noise level of ouput is controlled by
+    // the blind rotate decomposition
+
+    let ciphertext_modulus_log = config.ciphertext_modulus_log;
+    let safe_variance = error::safe_variance_bound_2padbits(
+        precision,
+        ciphertext_modulus_log,
+        config.maximum_acceptable_error_probability,
+    );
+    let kappa =
+        error::sigma_scale_of_error_probability(config.maximum_acceptable_error_probability);
+
+    let consts = OptimizationDecompositionsConsts {
+        config,
+        kappa,
+        sum_size,
+        noise_factor,
+        safe_variance,
+    };
+
+    let mut state = OptimizationState {
+        best_solution: None,
+    };
+
+    // cut only on glwe_poly_size based of modulus switching noise
+    // assume this noise is increasing with lwe_intern_dim
+    let min_internal_lwe_dimensions = search_space.internal_lwe_dimensions[0];
+    let lower_bound_cut = |glwe_log_poly_size| {
+        // TODO: cut if min complexity is higher than current best
+        CUTS && estimate_modulus_switching_noise_with_binary_key(
+            min_internal_lwe_dimensions,
+            glwe_log_poly_size,
+            ciphertext_modulus_log,
+        ) > consts.safe_variance
+    };
+
+    let mut caches = persistent_caches.caches();
+
+    for &glwe_dim in &search_space.glwe_dimensions {
+        for &glwe_log_poly_size in &search_space.glwe_log_polynomial_sizes {
+            assert!(8 <= glwe_log_poly_size);
+            assert!(glwe_log_poly_size < 18);
+            if lower_bound_cut(glwe_log_poly_size) {
+                continue;
+            }
+
+            let glwe_params = GlweParameters {
+                log2_polynomial_size: glwe_log_poly_size,
+                glwe_dimension: glwe_dim,
+            };
+
+            let cmux_quantities = caches.cmux.pareto_quantities(glwe_params);
+
+            for &internal_dim in &search_space.internal_lwe_dimensions {
+                assert!(256 < internal_dim);
+
+                let ks_quantities = caches.keyswitch.pareto_quantities(internal_dim);
+
+                update_state_with_best_decompositions(
+                    &mut state,
+                    &consts,
+                    internal_dim,
+                    glwe_params,
+                    cmux_quantities,
+                    ks_quantities,
+                );
+            }
+        }
+    }
+
+    persistent_caches.backport(caches);
+
+    if let Some(sol) = state.best_solution {
+        assert!(0.0 <= sol.p_error && sol.p_error <= 1.0);
+        assert!(sol.p_error <= config.maximum_acceptable_error_probability * REL_EPSILON_PROBA);
+    }
+
+    state
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/config.rs

@@ -0,0 +1,88 @@
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+use crate::config::GpuPbsType;
+use crate::global_parameters::DEFAUT_DOMAINS;
+
+#[derive(Clone, Copy, Debug)]
+pub struct NoiseBoundConfig {
+    pub security_level: u64,
+    pub maximum_acceptable_error_probability: f64,
+    pub ciphertext_modulus_log: u32,
+}
+
+#[derive(Clone, Copy)]
+pub struct Config<'a> {
+    pub security_level: u64,
+    pub maximum_acceptable_error_probability: f64,
+    pub ciphertext_modulus_log: u32,
+    pub complexity_model: &'a dyn ComplexityModel,
+}
+
+#[derive(Clone, Debug)]
+pub struct SearchSpace {
+    pub glwe_log_polynomial_sizes: Vec<u64>,
+    pub glwe_dimensions: Vec<u64>,
+    pub internal_lwe_dimensions: Vec<u64>,
+}
+
+impl SearchSpace {
+    pub fn default_cpu() -> Self {
+        let glwe_log_polynomial_sizes: Vec<u64> = DEFAUT_DOMAINS
+            .glwe_pbs_constrained
+            .log2_polynomial_size
+            .as_vec();
+        let glwe_dimensions: Vec<u64> = DEFAUT_DOMAINS.glwe_pbs_constrained.glwe_dimension.as_vec();
+        let internal_lwe_dimensions: Vec<u64> = DEFAUT_DOMAINS.free_glwe.glwe_dimension.as_vec();
+
+        Self {
+            glwe_log_polynomial_sizes,
+            glwe_dimensions,
+            internal_lwe_dimensions,
+        }
+    }
+
+    pub fn default_gpu_lowlat() -> Self {
+        // https://github.com/zama-ai/concrete-core/blob/6b52182ab44c4b39ddebca1c457e1096fb687801/concrete-cuda/cuda/src/bootstrap_low_latency.cu#L156
+        let glwe_log_polynomial_sizes: Vec<u64> = (9..=11).collect();
+
+        // https://github.com/zama-ai/concrete-core/blob/6b52182ab44c4b39ddebca1c457e1096fb687801/concrete-cuda/cuda/src/bootstrap_low_latency.cu#L154
+        let glwe_dimensions: Vec<u64> = vec![1];
+
+        let internal_lwe_dimensions: Vec<u64> = DEFAUT_DOMAINS.free_glwe.glwe_dimension.as_vec();
+
+        Self {
+            glwe_log_polynomial_sizes,
+            glwe_dimensions,
+            internal_lwe_dimensions,
+        }
+    }
+
+    pub fn default_gpu_amortized() -> Self {
+        // https://github.com/zama-ai/concrete-core/blob/6b52182ab44c4b39ddebca1c457e1096fb687801/concrete-cuda/cuda/src/bootstrap_amortized.cu#L79
+        let glwe_log_polynomial_sizes: Vec<u64> = (9..=13).collect();
+
+        // https://github.com/zama-ai/concrete-core/blob/6b52182ab44c4b39ddebca1c457e1096fb687801/concrete-cuda/cuda/src/bootstrap_amortized.cu#L78
+        let glwe_dimensions: Vec<u64> = vec![1];
+
+        let internal_lwe_dimensions: Vec<u64> = DEFAUT_DOMAINS.free_glwe.glwe_dimension.as_vec();
+
+        Self {
+            glwe_log_polynomial_sizes,
+            glwe_dimensions,
+            internal_lwe_dimensions,
+        }
+    }
+    pub fn default(processing_unit: config::ProcessingUnit) -> Self {
+        match processing_unit {
+            config::ProcessingUnit::Cpu => Self::default_cpu(),
+            config::ProcessingUnit::Gpu {
+                pbs_type: GpuPbsType::Amortized,
+                ..
+            } => Self::default_gpu_amortized(),
+            config::ProcessingUnit::Gpu {
+                pbs_type: GpuPbsType::Lowlat,
+                ..
+            } => Self::default_gpu_lowlat(),
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/mod.rs

@@ -0,0 +1 @@
+pub mod solo_key;

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/solo_key/analyze.rs

@@ -0,0 +1,889 @@
+use super::symbolic_variance::{SymbolicVariance, VarianceOrigin};
+use crate::dag::operator::{
+    dot_kind, DotKind, LevelledComplexity, OperatorIndex, Precision, Shape,
+};
+use crate::dag::rewrite::round::expand_round;
+use crate::dag::unparametrized;
+use crate::noise_estimator::error;
+use crate::noise_estimator::p_error::{combine_errors, repeat_p_error};
+use crate::optimization::config::NoiseBoundConfig;
+use crate::utils::square;
+use std::collections::{HashMap, HashSet};
+
+// private short convention
+use {DotKind as DK, VarianceOrigin as VO};
+type Op = unparametrized::UnparameterizedOperator;
+
+fn first<'a, Property>(inputs: &[OperatorIndex], properties: &'a [Property]) -> &'a Property {
+    &properties[inputs[0].i]
+}
+
+fn assert_all_same<Property: PartialEq + std::fmt::Debug>(
+    inputs: &[OperatorIndex],
+    properties: &[Property],
+) {
+    let first = first(inputs, properties);
+    for input in inputs.iter().skip(1) {
+        assert_eq!(first, &properties[input.i]);
+    }
+}
+
+fn assert_inputs_uniform_precisions(
+    op: &unparametrized::UnparameterizedOperator,
+    out_precisions: &[Precision],
+) {
+    if let Op::Dot { inputs, .. } | Op::LevelledOp { inputs, .. } = op {
+        assert_all_same(inputs, out_precisions);
+    }
+}
+
+fn assert_dot_uniform_inputs_shape(
+    op: &unparametrized::UnparameterizedOperator,
+    out_shapes: &[Shape],
+) {
+    if let Op::Dot { inputs, .. } = op {
+        assert_all_same(inputs, out_shapes);
+    }
+}
+
+fn assert_non_empty_inputs(op: &unparametrized::UnparameterizedOperator) {
+    if let Op::Dot { inputs, .. } | Op::LevelledOp { inputs, .. } = op {
+        assert!(!inputs.is_empty());
+    }
+}
+
+fn assert_dag_correctness(dag: &unparametrized::OperationDag) {
+    for op in &dag.operators {
+        assert_non_empty_inputs(op);
+        assert_inputs_uniform_precisions(op, &dag.out_precisions);
+        assert_dot_uniform_inputs_shape(op, &dag.out_shapes);
+    }
+}
+
+pub fn has_round(dag: &unparametrized::OperationDag) -> bool {
+    for op in &dag.operators {
+        if matches!(op, Op::Round { .. }) {
+            return true;
+        }
+    }
+    false
+}
+
+fn assert_no_round(dag: &unparametrized::OperationDag) {
+    assert!(!has_round(dag));
+}
+
+fn assert_valid_variances(dag: &OperationDag) {
+    for &out_variance in &dag.out_variances {
+        assert!(
+            SymbolicVariance::ZERO == out_variance // Special case of multiply by 0
+            || 1.0 <= out_variance.input_coeff
+            || 1.0 <= out_variance.lut_coeff
+        );
+    }
+}
+
+fn assert_properties_correctness(dag: &OperationDag) {
+    assert_valid_variances(dag);
+}
+
+fn variance_origin(inputs: &[OperatorIndex], out_variances: &[SymbolicVariance]) -> VarianceOrigin {
+    let first_origin = first(inputs, out_variances).origin();
+    for input in inputs.iter().skip(1) {
+        let item = &out_variances[input.i];
+        if first_origin != item.origin() {
+            return VO::Mixed;
+        }
+    }
+    first_origin
+}
+
+#[derive(Clone, Debug)]
+pub struct OperationDag {
+    pub operators: Vec<Op>,
+    // Collect all operators ouput variances
+    pub out_variances: Vec<SymbolicVariance>,
+    pub nb_luts: u64,
+    // True if all luts have noise with origin VarianceOrigin::Input
+    pub has_only_luts_with_inputs: bool,
+    // The full dag levelled complexity
+    pub levelled_complexity: LevelledComplexity,
+    // Dominating variances and bounds per precision
+    pub constraints_by_precisions: Vec<VariancesAndBound>,
+}
+
+#[derive(Clone, Debug)]
+pub struct VariancesAndBound {
+    pub precision: Precision,
+    pub safe_variance_bound: f64,
+    pub nb_luts: u64,
+    // All dominating final variance factor not entering a lut (usually final levelledOp)
+    pub pareto_output: Vec<SymbolicVariance>,
+    // All dominating variance factor entering a lut
+    pub pareto_in_lut: Vec<SymbolicVariance>,
+    // All counted variances for computing exact full dag error probability
+    pub all_output: Vec<(u64, SymbolicVariance)>,
+    pub all_in_lut: Vec<(u64, SymbolicVariance)>,
+}
+
+fn out_variance(
+    op: &unparametrized::UnparameterizedOperator,
+    out_shapes: &[Shape],
+    out_variances: &mut [SymbolicVariance],
+) -> SymbolicVariance {
+    // Maintain a linear combination of input_variance and lut_out_variance
+    // TODO: track each elements instead of container
+    match op {
+        Op::Input { .. } => SymbolicVariance::INPUT,
+        Op::Lut { .. } => SymbolicVariance::LUT,
+        Op::LevelledOp { inputs, manp, .. } => {
+            let variance_factor = SymbolicVariance::manp_to_variance_factor(*manp);
+            let origin = match variance_origin(inputs, out_variances) {
+                    VO::Input => SymbolicVariance::INPUT,
+                    VO::Lut | VO::Mixed /* Mixed: assume the worst */
+                    => SymbolicVariance::LUT
+            };
+            origin * variance_factor
+        }
+        Op::Dot {
+            inputs, weights, ..
+        } => {
+            let input_shape = first(inputs, out_shapes);
+            let kind = dot_kind(inputs.len() as u64, input_shape, weights);
+            match kind {
+                DK::Simple | DK::Tensor | DK::Broadcast => {
+                    let first_input = inputs[0];
+                    let mut out_variance = SymbolicVariance::ZERO;
+                    for (j, &weight) in weights.values.iter().enumerate() {
+                        let k = if kind == DK::Simple {
+                            inputs[j].i
+                        } else {
+                            first_input.i
+                        };
+                        out_variance += out_variances[k] * square(weight);
+                    }
+                    out_variance
+                }
+                DK::CompatibleTensor { .. } => todo!("TODO"),
+                DK::Unsupported { .. } => panic!("Unsupported"),
+            }
+        }
+        Op::UnsafeCast { input, .. } => out_variances[input.i],
+        Op::Round { .. } => {
+            unreachable!("Round should have been either expanded or integrated to a lut")
+        }
+    }
+}
+
+fn out_variances(dag: &unparametrized::OperationDag) -> Vec<SymbolicVariance> {
+    let nb_ops = dag.operators.len();
+    let mut out_variances = Vec::with_capacity(nb_ops);
+    for op in &dag.operators {
+        let vf = out_variance(op, &dag.out_shapes, &mut out_variances);
+        out_variances.push(vf);
+    }
+    out_variances
+}
+
+fn extra_final_values_to_check(dag: &unparametrized::OperationDag) -> Vec<bool> {
+    let nb_ops = dag.operators.len();
+    let mut extra_values_to_check = vec![true; nb_ops];
+    for op in &dag.operators {
+        match op {
+            Op::Input { .. } => (),
+            Op::Lut { input, .. } | Op::UnsafeCast { input, .. } | Op::Round { input, .. } => {
+                extra_values_to_check[input.i] = false;
+            }
+            Op::Dot { inputs, .. } | Op::LevelledOp { inputs, .. } => {
+                for input in inputs {
+                    extra_values_to_check[input.i] = false;
+                }
+            }
+        }
+    }
+    extra_values_to_check
+}
+
+fn extra_final_variances(
+    dag: &unparametrized::OperationDag,
+    out_variances: &[SymbolicVariance],
+) -> Vec<(Precision, Shape, SymbolicVariance)> {
+    extra_final_values_to_check(dag)
+        .iter()
+        .enumerate()
+        .filter_map(|(i, &is_final)| {
+            if is_final {
+                Some((
+                    dag.out_precisions[i],
+                    dag.out_shapes[i].clone(),
+                    out_variances[i],
+                ))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+fn in_luts_variance(
+    dag: &unparametrized::OperationDag,
+    out_variances: &[SymbolicVariance],
+) -> Vec<(Precision, Shape, SymbolicVariance)> {
+    dag.operators
+        .iter()
+        .enumerate()
+        .filter_map(|(i, op)| {
+            if let &Op::Lut { input, .. } = op {
+                Some((
+                    dag.out_precisions[input.i],
+                    dag.out_shapes[i].clone(),
+                    out_variances[input.i],
+                ))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+fn op_levelled_complexity(
+    op: &unparametrized::UnparameterizedOperator,
+    out_shapes: &[Shape],
+) -> LevelledComplexity {
+    match op {
+        Op::Dot {
+            inputs, weights, ..
+        } => {
+            let input_shape = first(inputs, out_shapes);
+            let kind = dot_kind(inputs.len() as u64, input_shape, weights);
+            match kind {
+                DK::Simple | DK::Tensor | DK::Broadcast | DK::CompatibleTensor => {
+                    LevelledComplexity::ADDITION * (inputs.len() as u64) * input_shape.flat_size()
+                }
+                DK::Unsupported { .. } => panic!("Unsupported"),
+            }
+        }
+        Op::LevelledOp { complexity, .. } => *complexity,
+        Op::Input { .. } | Op::Lut { .. } | Op::UnsafeCast { .. } => LevelledComplexity::ZERO,
+        Op::Round { .. } => {
+            unreachable!("Round should have been either expanded or integrated to a lut")
+        }
+    }
+}
+
+fn levelled_complexity(dag: &unparametrized::OperationDag) -> LevelledComplexity {
+    let mut levelled_complexity = LevelledComplexity::ZERO;
+    for op in &dag.operators {
+        levelled_complexity += op_levelled_complexity(op, &dag.out_shapes);
+    }
+    levelled_complexity
+}
+
+pub fn lut_count_from_dag(dag: &unparametrized::OperationDag) -> u64 {
+    let mut count = 0;
+    for (i, op) in dag.operators.iter().enumerate() {
+        if let Op::Lut { .. } = op {
+            count += dag.out_shapes[i].flat_size();
+        }
+    }
+    count
+}
+
+fn safe_noise_bound(precision: Precision, noise_config: &NoiseBoundConfig) -> f64 {
+    error::safe_variance_bound_2padbits(
+        precision as u64,
+        noise_config.ciphertext_modulus_log,
+        noise_config.maximum_acceptable_error_probability,
+    )
+}
+
+fn constraints_by_precisions(
+    out_precisions: &[Precision],
+    final_variances: &[(Precision, Shape, SymbolicVariance)],
+    in_luts_variance: &[(Precision, Shape, SymbolicVariance)],
+    noise_config: &NoiseBoundConfig,
+) -> Vec<VariancesAndBound> {
+    let precisions: HashSet<Precision> = out_precisions.iter().copied().collect();
+    let mut precisions: Vec<Precision> = precisions.iter().copied().collect();
+    let to_noise_summary = |precision: &Precision| {
+        constraint_for_one_precision(
+            *precision as Precision,
+            final_variances,
+            in_luts_variance,
+            safe_noise_bound(*precision as Precision, noise_config),
+        )
+    };
+    // High precision first
+    precisions.sort_unstable();
+    precisions.iter().rev().map(to_noise_summary).collect()
+}
+
+fn select_precision<T1: Clone, T2: Copy>(
+    target_precision: Precision,
+    v: &[(Precision, T1, T2)],
+) -> Vec<(T1, T2)> {
+    v.iter()
+        .filter_map(|(p, s, t)| {
+            if *p == target_precision {
+                Some((s.clone(), *t))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+fn counted_symbolic_variance(
+    symbolic_variances: &[(Shape, SymbolicVariance)],
+) -> Vec<(u64, SymbolicVariance)> {
+    pub fn exact_key(v: &SymbolicVariance) -> (u64, u64) {
+        (v.lut_coeff.to_bits(), v.input_coeff.to_bits())
+    }
+    let mut count: HashMap<(u64, u64), u64> = HashMap::new();
+    for (s, v) in symbolic_variances {
+        *count.entry(exact_key(v)).or_insert(0) += s.flat_size();
+    }
+    let mut res = Vec::new();
+    res.reserve_exact(count.len());
+    for (_s, v) in symbolic_variances {
+        if let Some(c) = count.remove(&exact_key(v)) {
+            res.push((c, *v));
+        }
+    }
+    res
+}
+
+fn constraint_for_one_precision(
+    target_precision: Precision,
+    extra_final_variances: &[(Precision, Shape, SymbolicVariance)],
+    in_luts_variance: &[(Precision, Shape, SymbolicVariance)],
+    safe_noise_bound: f64,
+) -> VariancesAndBound {
+    let extra_finals_variance = select_precision(target_precision, extra_final_variances);
+    let in_luts_variance = select_precision(target_precision, in_luts_variance);
+    let nb_luts = in_luts_variance.len() as u64;
+    let all_output = counted_symbolic_variance(&extra_finals_variance);
+    let all_in_lut = counted_symbolic_variance(&in_luts_variance);
+    let remove_shape = |t: &(Shape, SymbolicVariance)| t.1;
+    let extra_finals_variance = extra_finals_variance.iter().map(remove_shape).collect();
+    let in_luts_variance = in_luts_variance.iter().map(remove_shape).collect();
+    let pareto_vfs_final = SymbolicVariance::reduce_to_pareto_front(extra_finals_variance);
+    let pareto_vfs_in_lut = SymbolicVariance::reduce_to_pareto_front(in_luts_variance);
+    VariancesAndBound {
+        precision: target_precision,
+        safe_variance_bound: safe_noise_bound,
+        nb_luts,
+        pareto_output: pareto_vfs_final,
+        pareto_in_lut: pareto_vfs_in_lut,
+        all_output,
+        all_in_lut,
+    }
+}
+
+pub fn worst_log_norm_for_wop(dag: &unparametrized::OperationDag) -> f64 {
+    assert_dag_correctness(dag);
+    assert_no_round(dag);
+    let out_variances = out_variances(dag);
+    let in_luts_variance = in_luts_variance(dag, &out_variances);
+    let coeffs = in_luts_variance
+        .iter()
+        .map(|(_precision, _shape, symbolic_variance)| {
+            symbolic_variance.lut_coeff + symbolic_variance.input_coeff
+        })
+        .filter(|v| *v >= 1.0);
+    let worst = coeffs.fold(1.0, f64::max);
+    worst.log2()
+}
+
+pub fn analyze(
+    dag: &unparametrized::OperationDag,
+    noise_config: &NoiseBoundConfig,
+) -> OperationDag {
+    assert_dag_correctness(dag);
+    let dag = &expand_round(dag);
+    assert_no_round(dag);
+    let out_variances = out_variances(dag);
+    let in_luts_variance = in_luts_variance(dag, &out_variances);
+    let nb_luts = lut_count_from_dag(dag);
+    let extra_final_variances = extra_final_variances(dag, &out_variances);
+    let levelled_complexity = levelled_complexity(dag);
+    let constraints_by_precisions = constraints_by_precisions(
+        &dag.out_precisions,
+        &extra_final_variances,
+        &in_luts_variance,
+        noise_config,
+    );
+    let has_only_luts_with_inputs = in_luts_variance
+        .iter()
+        .all(|(_, _, sb)| sb.origin() == VarianceOrigin::Input);
+    let result = OperationDag {
+        operators: dag.operators.clone(),
+        out_variances,
+        nb_luts,
+        levelled_complexity,
+        constraints_by_precisions,
+        has_only_luts_with_inputs,
+    };
+    assert_properties_correctness(&result);
+    result
+}
+
+fn max_update(current: &mut f64, candidate: f64) {
+    if candidate > *current {
+        *current = candidate;
+    }
+}
+
+// Compute the maximum attained variance for the full dag
+// TODO take a noise summary => peek_error or global error
+fn peak_variance_per_constraint(
+    constraint: &VariancesAndBound,
+    input_noise_out: f64,
+    blind_rotate_noise_out: f64,
+    noise_keyswitch: f64,
+    noise_modulus_switching: f64,
+) -> f64 {
+    assert!(input_noise_out < blind_rotate_noise_out || blind_rotate_noise_out == 0.0);
+    // the maximal variance encountered as an output that can be decrypted
+    let mut variance_output = 0.0;
+    for vf in &constraint.pareto_output {
+        max_update(
+            &mut variance_output,
+            vf.eval(input_noise_out, blind_rotate_noise_out),
+        );
+    }
+    if constraint.pareto_in_lut.is_empty() {
+        return variance_output;
+    }
+    // the maximal variance encountered during a lut computation
+    let mut variance_in_lut = 0.0;
+    for vf in &constraint.pareto_in_lut {
+        max_update(
+            &mut variance_in_lut,
+            vf.eval(input_noise_out, blind_rotate_noise_out),
+        );
+    }
+    let peek_in_lut = variance_in_lut + noise_keyswitch + noise_modulus_switching;
+    peek_in_lut.max(variance_output)
+}
+
+// Compute the maximum attained relative variance for the full dag
+fn peak_relative_variance(
+    dag: &OperationDag,
+    input_noise_out: f64,
+    blind_rotate_noise_out: f64,
+    noise_keyswitch: f64,
+    noise_modulus_switching: f64,
+) -> (f64, f64) {
+    assert!(!dag.constraints_by_precisions.is_empty());
+    assert!(input_noise_out <= blind_rotate_noise_out);
+    let mut max_relative_var = 0.0;
+    let mut safe_noise = 0.0;
+    for ns in &dag.constraints_by_precisions {
+        let variance_max = peak_variance_per_constraint(
+            ns,
+            input_noise_out,
+            blind_rotate_noise_out,
+            noise_keyswitch,
+            noise_modulus_switching,
+        );
+        let relative_var = variance_max / ns.safe_variance_bound;
+        if max_relative_var < relative_var {
+            max_relative_var = relative_var;
+            safe_noise = ns.safe_variance_bound;
+        }
+    }
+    (max_relative_var, safe_noise)
+}
+
+fn p_error_from_relative_variance(relative_variance: f64, kappa: f64) -> f64 {
+    let sigma_scale = kappa / relative_variance.sqrt();
+    error::error_probability_of_sigma_scale(sigma_scale)
+}
+
+fn p_error_per_constraint(
+    constraint: &VariancesAndBound,
+    input_noise_out: f64,
+    blind_rotate_noise_out: f64,
+    noise_keyswitch: f64,
+    noise_modulus_switching: f64,
+    kappa: f64,
+) -> f64 {
+    // Note: no log probability to keep accuracy near 0, 0 is a fine answer when p_success is very small.
+    let mut p_error = 0.0;
+    for &(count, vf) in &constraint.all_output {
+        assert!(0 < count);
+        let variance = vf.eval(input_noise_out, blind_rotate_noise_out);
+        let relative_variance = variance / constraint.safe_variance_bound;
+        let vf_p_error = p_error_from_relative_variance(relative_variance, kappa);
+
+        p_error = combine_errors(p_error, repeat_p_error(vf_p_error, count));
+    }
+    // the maximal variance encountered during a lut computation
+    for &(count, vf) in &constraint.all_in_lut {
+        assert!(0 < count);
+        let variance = vf.eval(input_noise_out, blind_rotate_noise_out);
+        let relative_variance =
+            (variance + noise_keyswitch + noise_modulus_switching) / constraint.safe_variance_bound;
+        let vf_p_error = p_error_from_relative_variance(relative_variance, kappa);
+
+        p_error = combine_errors(p_error, repeat_p_error(vf_p_error, count));
+    }
+    p_error
+}
+
+impl OperationDag {
+    pub fn peek_p_error(
+        &self,
+        input_noise_out: f64,
+        blind_rotate_noise_out: f64,
+        noise_keyswitch: f64,
+        noise_modulus_switching: f64,
+        kappa: f64,
+    ) -> (f64, f64) {
+        let (relative_var, variance_bound) = peak_relative_variance(
+            self,
+            input_noise_out,
+            blind_rotate_noise_out,
+            noise_keyswitch,
+            noise_modulus_switching,
+        );
+        (
+            p_error_from_relative_variance(relative_var, kappa),
+            relative_var * variance_bound,
+        )
+    }
+    pub fn global_p_error(
+        &self,
+        input_noise_out: f64,
+        blind_rotate_noise_out: f64,
+        noise_keyswitch: f64,
+        noise_modulus_switching: f64,
+        kappa: f64,
+    ) -> f64 {
+        let mut p_error = 0.0;
+        for ns in &self.constraints_by_precisions {
+            let p_error_c = p_error_per_constraint(
+                ns,
+                input_noise_out,
+                blind_rotate_noise_out,
+                noise_keyswitch,
+                noise_modulus_switching,
+                kappa,
+            );
+
+            p_error = combine_errors(p_error, p_error_c);
+        }
+        assert!(0.0 <= p_error && p_error <= 1.0);
+        p_error
+    }
+
+    pub fn feasible(
+        &self,
+        input_noise_out: f64,
+        blind_rotate_noise_out: f64,
+        noise_keyswitch: f64,
+        noise_modulus_switching: f64,
+    ) -> bool {
+        for ns in &self.constraints_by_precisions {
+            if peak_variance_per_constraint(
+                ns,
+                input_noise_out,
+                blind_rotate_noise_out,
+                noise_keyswitch,
+                noise_modulus_switching,
+            ) > ns.safe_variance_bound
+            {
+                return false;
+            }
+        }
+        true
+    }
+
+    pub fn complexity(&self, input_lwe_dimension: u64, one_lut_cost: f64) -> f64 {
+        let luts_cost = one_lut_cost * (self.nb_luts as f64);
+        let levelled_cost = self.levelled_complexity.cost(input_lwe_dimension);
+        luts_cost + levelled_cost
+    }
+
+    pub fn levelled_complexity(&self, input_lwe_dimension: u64) -> f64 {
+        self.levelled_complexity.cost(input_lwe_dimension)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::dag::operator::{FunctionTable, LevelledComplexity, Shape, Weights};
+    use crate::dag::unparametrized;
+    use crate::utils::square;
+
+    fn assert_f64_eq(v: f64, expected: f64) {
+        approx::assert_relative_eq!(v, expected, epsilon = f64::EPSILON);
+    }
+
+    impl OperationDag {
+        pub fn constraint(&self) -> VariancesAndBound {
+            assert!(!self.constraints_by_precisions.is_empty());
+            assert_eq!(self.constraints_by_precisions.len(), 1);
+            self.constraints_by_precisions[0].clone()
+        }
+    }
+
+    const _4_SIGMA: f64 = 1.0 - 0.999_936_657_516;
+
+    const CONFIG: NoiseBoundConfig = NoiseBoundConfig {
+        security_level: 128,
+        ciphertext_modulus_log: 64,
+        maximum_acceptable_error_probability: _4_SIGMA,
+    };
+
+    fn analyze(dag: &unparametrized::OperationDag) -> super::OperationDag {
+        super::analyze(dag, &CONFIG)
+    }
+
+    #[test]
+    fn test_1_input() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::number());
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        assert_eq!(analysis.out_variances[input1.i], SymbolicVariance::INPUT);
+        assert_eq!(graph.out_shapes[input1.i], Shape::number());
+        assert_eq!(analysis.levelled_complexity, LevelledComplexity::ZERO);
+        assert_eq!(graph.out_precisions[input1.i], 1);
+        assert_f64_eq(complexity_cost, 0.0);
+        assert!(analysis.nb_luts == 0);
+        let constraint = analysis.constraint();
+        assert!(constraint.pareto_output.len() == 1);
+        assert_f64_eq(constraint.pareto_output[0].input_coeff, 1.0);
+        assert_f64_eq(constraint.pareto_output[0].lut_coeff, 0.0);
+        assert!(constraint.pareto_in_lut.is_empty());
+    }
+
+    #[test]
+    fn test_1_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(8, Shape::number());
+        let lut1 = graph.add_lut(input1, FunctionTable::UNKWOWN, 8);
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        assert!(analysis.out_variances[lut1.i] == SymbolicVariance::LUT);
+        assert!(graph.out_shapes[lut1.i] == Shape::number());
+        assert!(analysis.levelled_complexity == LevelledComplexity::ZERO);
+        assert_eq!(graph.out_precisions[lut1.i], 8);
+        assert_f64_eq(one_lut_cost, complexity_cost);
+        let constraint = analysis.constraint();
+        assert!(constraint.pareto_output.len() == 1);
+        assert!(constraint.pareto_in_lut.len() == 1);
+        assert_f64_eq(constraint.pareto_output[0].input_coeff, 0.0);
+        assert_f64_eq(constraint.pareto_output[0].lut_coeff, 1.0);
+        assert_f64_eq(constraint.pareto_in_lut[0].input_coeff, 1.0);
+        assert_f64_eq(constraint.pareto_in_lut[0].lut_coeff, 0.0);
+    }
+
+    #[test]
+    fn test_1_dot() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::number());
+        let weights = Weights::vector([1, 2]);
+        let norm2: f64 = 1.0 * 1.0 + 2.0 * 2.0;
+        let dot = graph.add_dot([input1, input1], weights);
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        let expected_var = SymbolicVariance {
+            input_coeff: norm2,
+            lut_coeff: 0.0,
+        };
+        assert!(analysis.out_variances[dot.i] == expected_var);
+        assert!(graph.out_shapes[dot.i] == Shape::number());
+        assert!(analysis.levelled_complexity == LevelledComplexity::ADDITION * 2);
+        assert_eq!(graph.out_precisions[dot.i], 1);
+        let expected_dot_cost = (2 * lwe_dim) as f64;
+        assert_f64_eq(expected_dot_cost, complexity_cost);
+        let constraint = analysis.constraint();
+        assert!(constraint.pareto_in_lut.is_empty());
+        assert!(constraint.pareto_output.len() == 1);
+        assert_f64_eq(constraint.pareto_output[0].input_coeff, 5.0);
+        assert_f64_eq(constraint.pareto_output[0].lut_coeff, 0.0);
+    }
+
+    #[test]
+    fn test_1_dot_levelled() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(3, Shape::number());
+        let cpx_dot = LevelledComplexity::ADDITION;
+        let weights = Weights::vector([1, 2]);
+        #[allow(clippy::imprecise_flops)]
+        let manp = (1.0 * 1.0 + 2.0 * 2_f64).sqrt();
+        let dot = graph.add_levelled_op([input1, input1], cpx_dot, manp, Shape::number(), "dot");
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        assert!(analysis.out_variances[dot.i].origin() == VO::Input);
+        assert_eq!(graph.out_precisions[dot.i], 3);
+        let expected_square_norm2 = weights.square_norm2() as f64;
+        let actual_square_norm2 = analysis.out_variances[dot.i].input_coeff;
+        // Due to call on log2() to compute manp the result is not exact
+        assert_f64_eq(actual_square_norm2, expected_square_norm2);
+        assert!(analysis.levelled_complexity == LevelledComplexity::ADDITION);
+        assert_f64_eq(lwe_dim as f64, complexity_cost);
+        let constraint = analysis.constraint();
+        assert!(constraint.pareto_in_lut.is_empty());
+        assert!(constraint.pareto_output.len() == 1);
+        assert_eq!(constraint.pareto_output[0].origin(), VO::Input);
+        assert_f64_eq(constraint.pareto_output[0].input_coeff, 5.0);
+    }
+
+    #[test]
+    fn test_dot_tensorized_lut_dot_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::vector(2));
+        let weights = &Weights::vector([1, 2]);
+        let dot1 = graph.add_dot([input1], weights);
+        let lut1 = graph.add_lut(dot1, FunctionTable::UNKWOWN, 1);
+        let dot2 = graph.add_dot([lut1, lut1], weights);
+        let lut2 = graph.add_lut(dot2, FunctionTable::UNKWOWN, 1);
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        let expected_var_dot1 = SymbolicVariance {
+            input_coeff: weights.square_norm2() as f64,
+            lut_coeff: 0.0,
+        };
+        let expected_var_lut1 = SymbolicVariance {
+            input_coeff: 0.0,
+            lut_coeff: 1.0,
+        };
+        let expected_var_dot2 = SymbolicVariance {
+            input_coeff: 0.0,
+            lut_coeff: weights.square_norm2() as f64,
+        };
+        let expected_var_lut2 = SymbolicVariance {
+            input_coeff: 0.0,
+            lut_coeff: 1.0,
+        };
+        assert!(analysis.out_variances[dot1.i] == expected_var_dot1);
+        assert!(analysis.out_variances[lut1.i] == expected_var_lut1);
+        assert!(analysis.out_variances[dot2.i] == expected_var_dot2);
+        assert!(analysis.out_variances[lut2.i] == expected_var_lut2);
+        assert!(analysis.levelled_complexity == LevelledComplexity::ADDITION * 4);
+        let expected_cost = (lwe_dim * 4) as f64 + 2.0 * one_lut_cost;
+        assert_f64_eq(expected_cost, complexity_cost);
+        let constraint = analysis.constraint();
+        assert_eq!(constraint.pareto_output.len(), 1);
+        assert_eq!(constraint.pareto_output[0].origin(), VO::Lut);
+        assert_f64_eq(constraint.pareto_output[0].lut_coeff, 1.0);
+        assert_eq!(constraint.pareto_in_lut.len(), 1);
+        assert_eq!(constraint.pareto_in_lut[0].origin(), VO::Lut);
+        assert_f64_eq(
+            constraint.pareto_in_lut[0].lut_coeff,
+            weights.square_norm2() as f64,
+        );
+    }
+
+    #[test]
+    fn test_lut_dot_mixed_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::number());
+        let lut1 = graph.add_lut(input1, FunctionTable::UNKWOWN, 1);
+        let weights = &Weights::vector([2, 3]);
+        let dot1 = graph.add_dot([input1, lut1], weights);
+        let _lut2 = graph.add_lut(dot1, FunctionTable::UNKWOWN, 1);
+        let analysis = analyze(&graph);
+        let one_lut_cost = 100.0;
+        let lwe_dim = 1024;
+        let complexity_cost = analysis.complexity(lwe_dim, one_lut_cost);
+
+        let expected_cost = (2 * lwe_dim) as f64 + 2.0 * one_lut_cost;
+        assert_f64_eq(expected_cost, complexity_cost);
+        let expected_mixed = SymbolicVariance {
+            input_coeff: square(weights.values[0] as f64),
+            lut_coeff: square(weights.values[1] as f64),
+        };
+        let constraint = analysis.constraint();
+        assert_eq!(constraint.pareto_output.len(), 1);
+        assert_eq!(constraint.pareto_output[0], SymbolicVariance::LUT);
+        assert_eq!(constraint.pareto_in_lut.len(), 1);
+        assert_eq!(constraint.pareto_in_lut[0].origin(), VO::Mixed);
+        assert_eq!(constraint.pareto_in_lut[0], expected_mixed);
+    }
+
+    #[test]
+    fn test_multi_precision_input() {
+        let mut graph = unparametrized::OperationDag::new();
+        let max_precision: Precision = 5;
+        for i in 1..=max_precision {
+            let _ = graph.add_input(i, Shape::number());
+        }
+        let analysis = analyze(&graph);
+        assert!(analysis.constraints_by_precisions.len() == max_precision as usize);
+        let mut prev_safe_noise_bound = 0.0;
+        for (i, ns) in analysis.constraints_by_precisions.iter().enumerate() {
+            let i_prec = i as Precision;
+            assert_eq!(ns.precision, max_precision - i_prec);
+            assert_f64_eq(ns.pareto_output[0].input_coeff, 1.0);
+            assert!(prev_safe_noise_bound < ns.safe_variance_bound);
+            prev_safe_noise_bound = ns.safe_variance_bound;
+        }
+    }
+
+    #[test]
+    fn test_multi_precision_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let max_precision: Precision = 5;
+        for p in 1..=max_precision {
+            let input = graph.add_input(p, Shape::number());
+            let _lut = graph.add_lut(input, FunctionTable::UNKWOWN, p);
+        }
+        let analysis = analyze(&graph);
+        assert!(analysis.constraints_by_precisions.len() == max_precision as usize);
+        let mut prev_safe_noise_bound = 0.0;
+        for (i, ns) in analysis.constraints_by_precisions.iter().enumerate() {
+            let i_prec = i as Precision;
+            assert_eq!(ns.precision, max_precision - i_prec);
+            assert_eq!(ns.pareto_output.len(), 1);
+            assert_eq!(ns.pareto_in_lut.len(), 1);
+            assert_f64_eq(ns.pareto_output[0].input_coeff, 0.0);
+            assert_f64_eq(ns.pareto_output[0].lut_coeff, 1.0);
+            assert_f64_eq(ns.pareto_in_lut[0].input_coeff, 1.0);
+            assert_f64_eq(ns.pareto_in_lut[0].lut_coeff, 0.0);
+            assert!(prev_safe_noise_bound < ns.safe_variance_bound);
+            prev_safe_noise_bound = ns.safe_variance_bound;
+        }
+    }
+
+    #[test]
+    fn test_1_layer_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::number());
+        let _lut1 = graph.add_lut(input1, FunctionTable::UNKWOWN, 1);
+        let _lut2 = graph.add_lut(input1, FunctionTable::UNKWOWN, 1);
+        let analysis = analyze(&graph);
+        assert!(analysis.has_only_luts_with_inputs);
+    }
+
+    #[test]
+    fn test_2_layer_lut() {
+        let mut graph = unparametrized::OperationDag::new();
+        let input1 = graph.add_input(1, Shape::number());
+        let lut1 = graph.add_lut(input1, FunctionTable::UNKWOWN, 1);
+        let _lut2 = graph.add_lut(lut1, FunctionTable::UNKWOWN, 1);
+        let analysis = analyze(&graph);
+        assert!(!analysis.has_only_luts_with_inputs);
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/solo_key/mod.rs

@@ -0,0 +1,4 @@
+pub(crate) mod analyze;
+pub mod optimize;
+pub mod optimize_generic;
+pub(crate) mod symbolic_variance;

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/solo_key/optimize.rs

@@ -0,0 +1,973 @@
+use concrete_cpu_noise_model::gaussian_noise::noise::modulus_switching::estimate_modulus_switching_noise_with_binary_key;
+
+use super::analyze;
+use crate::dag::operator::{LevelledComplexity, Precision};
+use crate::dag::unparametrized;
+use crate::noise_estimator::error;
+use crate::optimization::atomic_pattern::{
+    OptimizationDecompositionsConsts, OptimizationState, Solution,
+};
+use crate::optimization::config::{Config, NoiseBoundConfig, SearchSpace};
+use crate::optimization::decomposition::cmux::CmuxComplexityNoise;
+use crate::optimization::decomposition::keyswitch::KsComplexityNoise;
+use crate::optimization::decomposition::PersistDecompCaches;
+use crate::parameters::GlweParameters;
+
+#[allow(clippy::too_many_lines)]
+fn update_best_solution_with_best_decompositions(
+    state: &mut OptimizationState,
+    consts: &OptimizationDecompositionsConsts,
+    dag: &analyze::OperationDag,
+    internal_dim: u64,
+    glwe_params: GlweParameters,
+    input_noise_out: f64,
+    noise_modulus_switching: f64,
+    cmux_pareto: &[CmuxComplexityNoise],
+    ks_pareto: &[KsComplexityNoise],
+) {
+    assert!(dag.nb_luts > 0);
+    let input_lwe_dimension = glwe_params.sample_extract_lwe_dimension();
+
+    let mut best_complexity = state.best_solution.map_or(f64::INFINITY, |s| s.complexity);
+    let mut best_variance = state.best_solution.map_or(f64::INFINITY, |s| s.noise_max);
+    let mut best_p_error = state.best_solution.map_or(f64::INFINITY, |s| s.p_error);
+
+    // by constructon br_pareto and ks_pareto are non-empty
+    let mut best_cmux = cmux_pareto[0];
+    let mut best_ks = ks_pareto[0];
+    let mut update_best_solution = false;
+
+    for &cmux_quantity in cmux_pareto {
+        let pbs_cost = cmux_quantity.complexity_br(internal_dim);
+        // increasing complexity, decreasing variance
+        let complexity = dag.complexity(input_lwe_dimension, pbs_cost);
+        if complexity > best_complexity {
+            // Since br_pareto is scanned by increasing complexity, we can stop
+            break;
+        }
+
+        let br_variance = cmux_quantity.noise_br(internal_dim);
+
+        let not_feasible =
+            !dag.feasible(input_noise_out, br_variance, 0.0, noise_modulus_switching);
+        if not_feasible {
+            continue;
+        }
+        for &ks_quantity in ks_pareto {
+            let complexity_keyswitch = ks_quantity.complexity(input_lwe_dimension);
+            let one_lut_cost = complexity_keyswitch + pbs_cost;
+            let complexity = dag.complexity(input_lwe_dimension, one_lut_cost);
+            let worse_complexity = complexity > best_complexity;
+            if worse_complexity {
+                // Since ks_pareto is scanned by increasing complexity, we can stop
+                break;
+            }
+            let ks_variance = ks_quantity.noise(input_lwe_dimension);
+
+            let not_feasible = !dag.feasible(
+                input_noise_out,
+                br_variance,
+                ks_variance,
+                noise_modulus_switching,
+            );
+            if not_feasible {
+                continue;
+            }
+
+            let (peek_p_error, variance) = dag.peek_p_error(
+                input_noise_out,
+                br_variance,
+                ks_variance,
+                noise_modulus_switching,
+                consts.kappa,
+            );
+            #[allow(clippy::float_cmp)]
+            let same_comlexity_no_few_errors =
+                complexity == best_complexity && peek_p_error >= best_p_error;
+            if same_comlexity_no_few_errors {
+                continue;
+            }
+
+            // The complexity is either better or equivalent with less errors
+            update_best_solution = true;
+            best_complexity = complexity;
+            best_p_error = peek_p_error;
+            best_variance = variance;
+            best_cmux = cmux_quantity;
+            best_ks = ks_quantity;
+        }
+    } // br ks
+
+    let ks_variance = best_ks.noise(input_lwe_dimension);
+
+    let br_variance = best_cmux.noise_br(internal_dim);
+
+    if update_best_solution {
+        state.best_solution = Some(Solution {
+            input_lwe_dimension,
+            internal_ks_output_lwe_dimension: internal_dim,
+            ks_decomposition_level_count: best_ks.decomp.level,
+            ks_decomposition_base_log: best_ks.decomp.log2_base,
+            glwe_polynomial_size: glwe_params.polynomial_size(),
+            glwe_dimension: glwe_params.glwe_dimension,
+            br_decomposition_level_count: best_cmux.decomp.level,
+            br_decomposition_base_log: best_cmux.decomp.log2_base,
+            complexity: best_complexity,
+            p_error: best_p_error,
+            global_p_error: dag.global_p_error(
+                input_noise_out,
+                br_variance,
+                ks_variance,
+                noise_modulus_switching,
+                consts.kappa,
+            ),
+            noise_max: best_variance,
+        });
+    }
+}
+
+const REL_EPSILON_PROBA: f64 = 1.0 + 1e-8;
+
+fn update_no_luts_solution(
+    state: &mut OptimizationState,
+    consts: &OptimizationDecompositionsConsts,
+    dag: &analyze::OperationDag,
+    glwe_params: GlweParameters,
+    input_noise_out: f64,
+) {
+    const CHECKED_IGNORED_NOISE: f64 = f64::MAX;
+    const UNDEFINED_PARAM: u64 = 0;
+
+    let input_lwe_dimension = glwe_params.sample_extract_lwe_dimension();
+
+    let best_complexity = state.best_solution.map_or(f64::INFINITY, |s| s.complexity);
+    let best_p_error = state.best_solution.map_or(f64::INFINITY, |s| s.p_error);
+
+    let complexity = if dag.levelled_complexity == LevelledComplexity::ZERO {
+        // The compiler has given a 0 levelled complexity.
+        // There is no way to compare solutions.
+        // Assuming linear complexity.
+        input_lwe_dimension as f64
+    } else {
+        dag.levelled_complexity(input_lwe_dimension)
+    };
+
+    if complexity > best_complexity {
+        return;
+    }
+
+    let (p_error, variance) = dag.peek_p_error(
+        input_noise_out,
+        CHECKED_IGNORED_NOISE,
+        CHECKED_IGNORED_NOISE,
+        CHECKED_IGNORED_NOISE,
+        consts.kappa,
+    );
+
+    #[allow(clippy::float_cmp)]
+    let same_complexity_no_few_errors = complexity == best_complexity && p_error >= best_p_error;
+    if same_complexity_no_few_errors {
+        return;
+    }
+    // The complexity is either better or equivalent with less errors
+    state.best_solution = Some(Solution {
+        input_lwe_dimension,
+        internal_ks_output_lwe_dimension: UNDEFINED_PARAM,
+        ks_decomposition_level_count: UNDEFINED_PARAM,
+        ks_decomposition_base_log: UNDEFINED_PARAM,
+        glwe_polynomial_size: glwe_params.polynomial_size(),
+        glwe_dimension: glwe_params.glwe_dimension,
+        br_decomposition_level_count: UNDEFINED_PARAM,
+        br_decomposition_base_log: UNDEFINED_PARAM,
+        complexity,
+        p_error,
+        global_p_error: dag.global_p_error(
+            input_noise_out,
+            CHECKED_IGNORED_NOISE,
+            CHECKED_IGNORED_NOISE,
+            CHECKED_IGNORED_NOISE,
+            consts.kappa,
+        ),
+        noise_max: variance,
+    });
+}
+
+fn minimal_variance(config: &Config, glwe_params: GlweParameters) -> f64 {
+    glwe_params.minimal_variance(config.ciphertext_modulus_log, config.security_level)
+}
+
+fn optimize_no_luts(
+    mut state: OptimizationState,
+    consts: &OptimizationDecompositionsConsts,
+    dag: &analyze::OperationDag,
+    search_space: &SearchSpace,
+) -> OptimizationState {
+    let not_feasible = |input_noise_out| !dag.feasible(input_noise_out, 0.0, 0.0, 0.0);
+    for &glwe_dim in &search_space.glwe_dimensions {
+        for &glwe_log_poly_size in &search_space.glwe_log_polynomial_sizes {
+            let glwe_params = GlweParameters {
+                log2_polynomial_size: glwe_log_poly_size,
+                glwe_dimension: glwe_dim,
+            };
+            let input_noise_out = minimal_variance(&consts.config, glwe_params);
+            if not_feasible(input_noise_out) {
+                continue;
+            }
+            update_no_luts_solution(&mut state, consts, dag, glwe_params, input_noise_out);
+        }
+    }
+    state
+}
+
+#[allow(clippy::too_many_lines)]
+pub fn optimize(
+    dag: &unparametrized::OperationDag,
+    config: Config,
+    search_space: &SearchSpace,
+    persistent_caches: &PersistDecompCaches,
+) -> OptimizationState {
+    let ciphertext_modulus_log = config.ciphertext_modulus_log;
+    let security_level = config.security_level;
+    let noise_config = NoiseBoundConfig {
+        security_level,
+        maximum_acceptable_error_probability: config.maximum_acceptable_error_probability,
+        ciphertext_modulus_log,
+    };
+    let &min_precision = dag.out_precisions.iter().min().unwrap();
+
+    let dag = analyze::analyze(dag, &noise_config);
+
+    let safe_variance = error::safe_variance_bound_2padbits(
+        min_precision as u64,
+        ciphertext_modulus_log,
+        config.maximum_acceptable_error_probability,
+    );
+    let kappa =
+        error::sigma_scale_of_error_probability(config.maximum_acceptable_error_probability);
+
+    let consts = OptimizationDecompositionsConsts {
+        config,
+        kappa,
+        sum_size: 0,            // superseeded by dag.complexity_cost
+        noise_factor: f64::NAN, // superseeded by dag.lut_variance_max
+        safe_variance,
+    };
+
+    let mut state = OptimizationState {
+        best_solution: None,
+    };
+
+    if dag.nb_luts == 0 {
+        return optimize_no_luts(state, &consts, &dag, search_space);
+    }
+    let mut caches = persistent_caches.caches();
+
+    let noise_modulus_switching = |glwe_log2_poly_size, internal_lwe_dimensions| {
+        estimate_modulus_switching_noise_with_binary_key(
+            internal_lwe_dimensions,
+            glwe_log2_poly_size,
+            ciphertext_modulus_log,
+        )
+    };
+
+    let not_feasible = |input_noise_out, noise_modulus_switching| {
+        !dag.feasible(input_noise_out, 0.0, 0.0, noise_modulus_switching)
+    };
+
+    for &glwe_dim in &search_space.glwe_dimensions {
+        for &glwe_log_poly_size in &search_space.glwe_log_polynomial_sizes {
+            let glwe_params = GlweParameters {
+                log2_polynomial_size: glwe_log_poly_size,
+                glwe_dimension: glwe_dim,
+            };
+            let input_noise_out = minimal_variance(&config, glwe_params);
+
+            let cmux_pareto = caches.cmux.pareto_quantities(glwe_params);
+
+            for &internal_dim in &search_space.internal_lwe_dimensions {
+                let ks_pareto = caches.keyswitch.pareto_quantities(internal_dim);
+
+                let noise_modulus_switching =
+                    noise_modulus_switching(glwe_log_poly_size, internal_dim);
+                if not_feasible(input_noise_out, noise_modulus_switching) {
+                    // noise_modulus_switching is increasing with internal_dim
+                    break;
+                }
+                update_best_solution_with_best_decompositions(
+                    &mut state,
+                    &consts,
+                    &dag,
+                    internal_dim,
+                    glwe_params,
+                    input_noise_out,
+                    noise_modulus_switching,
+                    cmux_pareto,
+                    ks_pareto,
+                );
+                if dag.nb_luts == 0 && state.best_solution.is_some() {
+                    return state;
+                }
+            }
+        }
+    }
+
+    persistent_caches.backport(caches);
+
+    if let Some(sol) = state.best_solution {
+        assert!(0.0 <= sol.p_error && sol.p_error <= 1.0);
+        assert!(0.0 <= sol.global_p_error && sol.global_p_error <= 1.0);
+        assert!(sol.p_error <= config.maximum_acceptable_error_probability * REL_EPSILON_PROBA);
+        assert!(sol.p_error <= sol.global_p_error * REL_EPSILON_PROBA);
+    }
+
+    state
+}
+
+pub fn optimize_v0(
+    sum_size: u64,
+    precision: u64,
+    config: Config,
+    noise_factor: f64,
+    search_space: &SearchSpace,
+    cache: &PersistDecompCaches,
+) -> OptimizationState {
+    use crate::dag::operator::{FunctionTable, Shape};
+    let same_scale_manp = 0.0;
+    let manp = noise_factor;
+    let out_shape = &Shape::number();
+    let complexity = LevelledComplexity::ADDITION * sum_size;
+    let comment = "dot";
+    let mut dag = unparametrized::OperationDag::new();
+    let precision = precision as Precision;
+    let input1 = dag.add_input(precision, out_shape);
+    let dot1 = dag.add_levelled_op([input1], complexity, same_scale_manp, out_shape, comment);
+    let lut1 = dag.add_lut(dot1, FunctionTable::UNKWOWN, precision);
+    let dot2 = dag.add_levelled_op([lut1], complexity, manp, out_shape, comment);
+    let _lut2 = dag.add_lut(dot2, FunctionTable::UNKWOWN, precision);
+    let mut state = optimize(&dag, config, search_space, cache);
+    if let Some(sol) = &mut state.best_solution {
+        sol.complexity /= 2.0;
+    }
+    state
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Instant;
+
+    use once_cell::sync::Lazy;
+
+    use super::*;
+    use crate::computing_cost::cpu::CpuComplexity;
+    use crate::config;
+    use crate::dag::operator::{FunctionTable, Shape, Weights};
+    use crate::noise_estimator::p_error::repeat_p_error;
+    use crate::optimization::config::SearchSpace;
+    use crate::optimization::dag::solo_key::symbolic_variance::VarianceOrigin;
+    use crate::optimization::{atomic_pattern, decomposition};
+    use crate::utils::square;
+
+    fn small_relative_diff(v1: f64, v2: f64) -> bool {
+        f64::abs(v1 - v2) / f64::max(v1, v2) <= 0.000_000_1
+    }
+
+    impl Solution {
+        fn assert_same_pbs_solution(&self, other: Self) -> bool {
+            let mut other = other;
+            other.global_p_error = self.global_p_error;
+            if small_relative_diff(self.noise_max, other.noise_max)
+                && small_relative_diff(self.p_error, other.p_error)
+            {
+                other.noise_max = self.noise_max;
+                other.p_error = self.p_error;
+            }
+            assert_eq!(self, &other);
+            self == &other
+        }
+    }
+
+    const _4_SIGMA: f64 = 1.0 - 0.999_936_657_516;
+
+    static SHARED_CACHES: Lazy<PersistDecompCaches> = Lazy::new(|| {
+        let processing_unit = config::ProcessingUnit::Cpu;
+        decomposition::cache(128, processing_unit, None, true)
+    });
+
+    fn optimize(dag: &unparametrized::OperationDag) -> OptimizationState {
+        let config = Config {
+            security_level: 128,
+            maximum_acceptable_error_probability: _4_SIGMA,
+            ciphertext_modulus_log: 64,
+            complexity_model: &CpuComplexity::default(),
+        };
+
+        let search_space = SearchSpace::default_cpu();
+
+        super::optimize(dag, config, &search_space, &SHARED_CACHES)
+    }
+
+    struct Times {
+        worst_time: u128,
+        dag_time: u128,
+    }
+
+    fn assert_f64_eq(v: f64, expected: f64) {
+        approx::assert_relative_eq!(v, expected, epsilon = f64::EPSILON);
+    }
+
+    #[test]
+    fn test_v0_parameter_ref() {
+        let mut times = Times {
+            worst_time: 0,
+            dag_time: 0,
+        };
+        for log_weight in 0..=16 {
+            let weight = 1 << log_weight;
+            for precision in 1..=9 {
+                v0_parameter_ref(precision, weight, &mut times);
+            }
+        }
+        assert!(times.worst_time * 3 > times.dag_time);
+    }
+
+    fn v0_parameter_ref(precision: u64, weight: u64, times: &mut Times) {
+        let processing_unit = config::ProcessingUnit::Cpu;
+
+        let search_space = SearchSpace::default(processing_unit);
+
+        let sum_size = 1;
+
+        let config = Config {
+            security_level: 128,
+            maximum_acceptable_error_probability: _4_SIGMA,
+            ciphertext_modulus_log: 64,
+            complexity_model: &CpuComplexity::default(),
+        };
+
+        let _ = optimize_v0(
+            sum_size,
+            precision,
+            config,
+            weight as f64,
+            &search_space,
+            &SHARED_CACHES,
+        );
+        // ensure cache is filled
+
+        let chrono = Instant::now();
+        let state = optimize_v0(
+            sum_size,
+            precision,
+            config,
+            weight as f64,
+            &search_space,
+            &SHARED_CACHES,
+        );
+
+        times.dag_time += chrono.elapsed().as_nanos();
+        let chrono = Instant::now();
+        let state_ref = atomic_pattern::optimize_one(
+            sum_size,
+            precision,
+            config,
+            weight as f64,
+            &search_space,
+            &SHARED_CACHES,
+        );
+        times.worst_time += chrono.elapsed().as_nanos();
+        assert_eq!(
+            state.best_solution.is_some(),
+            state_ref.best_solution.is_some()
+        );
+        if state.best_solution.is_none() {
+            return;
+        }
+        let sol = state.best_solution.unwrap();
+        let sol_ref = state_ref.best_solution.unwrap();
+        assert!(sol.assert_same_pbs_solution(sol_ref));
+        assert!(!sol.global_p_error.is_nan());
+        assert!(sol.p_error <= sol.global_p_error);
+        assert!(sol.global_p_error <= 1.0);
+    }
+
+    #[test]
+    fn test_v0_parameter_ref_with_dot() {
+        for log_weight in 0..=16 {
+            let weight = 1 << log_weight;
+            for precision in 1..=9 {
+                v0_parameter_ref_with_dot(precision, weight);
+            }
+        }
+    }
+
+    fn v0_parameter_ref_with_dot(precision: Precision, weight: i64) {
+        let processing_unit = config::ProcessingUnit::Cpu;
+        let security_level = 128;
+
+        let mut dag = unparametrized::OperationDag::new();
+        {
+            let input1 = dag.add_input(precision, Shape::number());
+            let dot1 = dag.add_dot([input1], [1]);
+            let lut1 = dag.add_lut(dot1, FunctionTable::UNKWOWN, precision);
+            let dot2 = dag.add_dot([lut1], [weight]);
+            let _lut2 = dag.add_lut(dot2, FunctionTable::UNKWOWN, precision);
+        }
+        {
+            let dag2 = analyze::analyze(
+                &dag,
+                &NoiseBoundConfig {
+                    security_level,
+                    maximum_acceptable_error_probability: _4_SIGMA,
+                    ciphertext_modulus_log: 64,
+                },
+            );
+            let constraint = dag2.constraint();
+            assert_eq!(constraint.pareto_output.len(), 1);
+            assert_eq!(constraint.pareto_in_lut.len(), 1);
+            assert_eq!(constraint.pareto_output[0].origin(), VarianceOrigin::Lut);
+            assert_f64_eq(1.0, constraint.pareto_output[0].lut_coeff);
+            assert!(constraint.pareto_in_lut.len() == 1);
+            assert_eq!(constraint.pareto_in_lut[0].origin(), VarianceOrigin::Lut);
+            assert_f64_eq(square(weight) as f64, constraint.pareto_in_lut[0].lut_coeff);
+        }
+
+        let search_space = SearchSpace::default(processing_unit);
+
+        let config = Config {
+            security_level,
+            maximum_acceptable_error_probability: _4_SIGMA,
+            ciphertext_modulus_log: 64,
+            complexity_model: &CpuComplexity::default(),
+        };
+
+        let state = optimize(&dag);
+        let state_ref = atomic_pattern::optimize_one(
+            1,
+            precision as u64,
+            config,
+            weight as f64,
+            &search_space,
+            &SHARED_CACHES,
+        );
+        assert_eq!(
+            state.best_solution.is_some(),
+            state_ref.best_solution.is_some()
+        );
+        if state.best_solution.is_none() {
+            return;
+        }
+        let sol = state.best_solution.unwrap();
+        let mut sol_ref = state_ref.best_solution.unwrap();
+        sol_ref.complexity *= 2.0 /* number of luts */;
+        assert!(sol.assert_same_pbs_solution(sol_ref));
+        assert!(!sol.global_p_error.is_nan());
+        assert!(sol.p_error <= sol.global_p_error);
+        assert!(sol.global_p_error <= 1.0);
+    }
+
+    fn no_lut_vs_lut(precision: Precision) {
+        let mut dag_lut = unparametrized::OperationDag::new();
+        let input1 = dag_lut.add_input(precision, Shape::number());
+        let _lut1 = dag_lut.add_lut(input1, FunctionTable::UNKWOWN, precision);
+
+        let mut dag_no_lut = unparametrized::OperationDag::new();
+        let _input2 = dag_no_lut.add_input(precision, Shape::number());
+
+        let state_no_lut = optimize(&dag_no_lut);
+        let state_lut = optimize(&dag_lut);
+        assert_eq!(
+            state_no_lut.best_solution.is_some(),
+            state_lut.best_solution.is_some()
+        );
+
+        if state_lut.best_solution.is_none() {
+            return;
+        }
+
+        let sol_no_lut = state_no_lut.best_solution.unwrap();
+        let sol_lut = state_lut.best_solution.unwrap();
+        assert!(sol_no_lut.complexity < sol_lut.complexity);
+    }
+
+    #[test]
+    fn test_lut_vs_no_lut() {
+        for precision in 1..=8 {
+            no_lut_vs_lut(precision);
+        }
+    }
+
+    fn lut_with_input_base_noise_better_than_lut_with_lut_base_noise(
+        precision: Precision,
+        weight: i64,
+    ) {
+        let weight = &Weights::number(weight);
+
+        let mut dag_1 = unparametrized::OperationDag::new();
+        {
+            let input1 = dag_1.add_input(precision, Shape::number());
+            let scaled_input1 = dag_1.add_dot([input1], weight);
+            let lut1 = dag_1.add_lut(scaled_input1, FunctionTable::UNKWOWN, precision);
+            let _lut2 = dag_1.add_lut(lut1, FunctionTable::UNKWOWN, precision);
+        }
+
+        let mut dag_2 = unparametrized::OperationDag::new();
+        {
+            let input1 = dag_2.add_input(precision, Shape::number());
+            let lut1 = dag_2.add_lut(input1, FunctionTable::UNKWOWN, precision);
+            let scaled_lut1 = dag_2.add_dot([lut1], weight);
+            let _lut2 = dag_2.add_lut(scaled_lut1, FunctionTable::UNKWOWN, precision);
+        }
+
+        let state_1 = optimize(&dag_1);
+        let state_2 = optimize(&dag_2);
+
+        if state_1.best_solution.is_none() {
+            assert!(state_2.best_solution.is_none());
+            return;
+        }
+        let sol_1 = state_1.best_solution.unwrap();
+        let sol_2 = state_2.best_solution.unwrap();
+        assert!(sol_1.complexity < sol_2.complexity || sol_1.p_error < sol_2.p_error);
+    }
+
+    #[test]
+    fn test_lut_with_input_base_noise_better_than_lut_with_lut_base_noise() {
+        for log_weight in 1..=16 {
+            let weight = 1 << log_weight;
+            for precision in 5..=9 {
+                lut_with_input_base_noise_better_than_lut_with_lut_base_noise(precision, weight);
+            }
+        }
+    }
+
+    fn lut_1_layer_has_better_complexity(precision: Precision) {
+        let dag_1_layer = {
+            let mut dag = unparametrized::OperationDag::new();
+            let input1 = dag.add_input(precision, Shape::number());
+            let _lut1 = dag.add_lut(input1, FunctionTable::UNKWOWN, precision);
+            let _lut2 = dag.add_lut(input1, FunctionTable::UNKWOWN, precision);
+            dag
+        };
+        let dag_2_layer = {
+            let mut dag = unparametrized::OperationDag::new();
+            let input1 = dag.add_input(precision, Shape::number());
+            let lut1 = dag.add_lut(input1, FunctionTable::UNKWOWN, precision);
+            let _lut2 = dag.add_lut(lut1, FunctionTable::UNKWOWN, precision);
+            dag
+        };
+
+        let sol_1_layer = optimize(&dag_1_layer).best_solution.unwrap();
+        let sol_2_layer = optimize(&dag_2_layer).best_solution.unwrap();
+        assert!(
+            sol_1_layer.complexity <= sol_2_layer.complexity,
+            "Precision: {} => sol_1_layer: {} ; sol_2_layer: {}",
+            precision,
+            sol_1_layer.complexity,
+            sol_2_layer.complexity
+        );
+    }
+
+    #[test]
+    fn test_lut_1_layer_is_better() {
+        // for some reason on 4, 5, 6, the complexity is already minimal
+        // this could be due to pre-defined pareto set
+        for precision in [1, 2, 3, 7, 8] {
+            lut_1_layer_has_better_complexity(precision);
+        }
+    }
+
+    fn circuit(dag: &mut unparametrized::OperationDag, precision: Precision, weight: i64) {
+        let input = dag.add_input(precision, Shape::number());
+        let dot1 = dag.add_dot([input], [weight]);
+        let lut1 = dag.add_lut(dot1, FunctionTable::UNKWOWN, precision);
+        let dot2 = dag.add_dot([lut1], [weight]);
+        let _lut2 = dag.add_lut(dot2, FunctionTable::UNKWOWN, precision);
+    }
+
+    fn assert_multi_precision_dominate_single(weight: i64) -> Option<bool> {
+        let low_precision = 4u8;
+        let high_precision = 5u8;
+        let mut dag_low = unparametrized::OperationDag::new();
+        let mut dag_high = unparametrized::OperationDag::new();
+        let mut dag_multi = unparametrized::OperationDag::new();
+
+        {
+            circuit(&mut dag_low, low_precision, weight);
+            circuit(&mut dag_high, high_precision, 1);
+            circuit(&mut dag_multi, low_precision, weight);
+            circuit(&mut dag_multi, high_precision, 1);
+        }
+        let state_multi = optimize(&dag_multi);
+
+        let mut sol_multi = state_multi.best_solution?;
+
+        let state_low = optimize(&dag_low);
+        let state_high = optimize(&dag_high);
+
+        let sol_low = state_low.best_solution.unwrap();
+        let sol_high = state_high.best_solution.unwrap();
+        sol_multi.complexity /= 2.0;
+        if sol_low.complexity < sol_high.complexity {
+            assert!(sol_high.assert_same_pbs_solution(sol_multi));
+            Some(true)
+        } else {
+            assert!(
+                sol_low.complexity < sol_multi.complexity
+                    || sol_low.assert_same_pbs_solution(sol_multi)
+            );
+            Some(false)
+        }
+    }
+
+    #[test]
+    fn test_multi_precision_dominate_single() {
+        let mut prev = Some(true); // true -> ... -> true -> false -> ... -> false
+        for log2_weight in 0..29 {
+            let weight = 1 << log2_weight;
+            let current = assert_multi_precision_dominate_single(weight);
+            #[allow(clippy::match_like_matches_macro)] // less readable
+            let authorized = match (prev, current) {
+                (Some(false), Some(true)) => false,
+                (None, Some(_)) => false,
+                _ => true,
+            };
+            assert!(authorized);
+            prev = current;
+        }
+    }
+
+    fn local_to_approx_global_p_error(local_p_error: f64, nb_pbs: u64) -> f64 {
+        #[allow(clippy::float_cmp)]
+        if local_p_error == 1f64 {
+            return 1.0;
+        }
+        #[allow(clippy::float_cmp)]
+        if local_p_error == 0f64 {
+            return 0.0;
+        }
+
+        assert!(local_p_error <= 1.0);
+        assert!(0.0 <= local_p_error);
+
+        repeat_p_error(local_p_error, nb_pbs)
+    }
+
+    #[test]
+    fn test_global_p_error_input() {
+        for precision in [4_u8, 8] {
+            for weight in [1, 3, 27, 243, 729] {
+                for dim in [1, 2, 16, 32] {
+                    let _ = check_global_p_error_input(dim, weight, precision);
+                }
+            }
+        }
+    }
+
+    fn check_global_p_error_input(dim: u64, weight: i64, precision: u8) -> f64 {
+        let shape = Shape::vector(dim);
+        let weights = Weights::number(weight);
+        let mut dag = unparametrized::OperationDag::new();
+        let input1 = dag.add_input(precision, shape);
+        let _dot1 = dag.add_dot([input1], weights); // this is just several multiply
+        let state = optimize(&dag);
+        let sol = state.best_solution.unwrap();
+        let worst_expected_p_error_dim = local_to_approx_global_p_error(sol.p_error, dim);
+        approx::assert_relative_eq!(sol.global_p_error, worst_expected_p_error_dim);
+        sol.global_p_error
+    }
+
+    #[test]
+    fn test_global_p_error_lut() {
+        for precision in [4_u8, 8] {
+            for weight in [1, 3, 27, 243, 729] {
+                for depth in [2, 16, 32] {
+                    check_global_p_error_lut(depth, weight, precision);
+                }
+            }
+        }
+    }
+
+    fn check_global_p_error_lut(depth: u64, weight: i64, precision: u8) {
+        let shape = Shape::number();
+        let weights = Weights::number(weight);
+        let mut dag = unparametrized::OperationDag::new();
+        let mut last_val = dag.add_input(precision, shape);
+        for _i in 0..depth {
+            let dot = dag.add_dot([last_val], &weights);
+            last_val = dag.add_lut(dot, FunctionTable::UNKWOWN, precision);
+        }
+        let state = optimize(&dag);
+        let sol = state.best_solution.unwrap();
+        // the first lut on input has reduced impact on error probability
+        let lower_nb_dominating_lut = depth - 1;
+        let lower_global_p_error =
+            local_to_approx_global_p_error(sol.p_error, lower_nb_dominating_lut);
+        let higher_global_p_error =
+            local_to_approx_global_p_error(sol.p_error, lower_nb_dominating_lut + 1);
+        assert!(lower_global_p_error <= sol.global_p_error);
+        assert!(sol.global_p_error <= higher_global_p_error);
+    }
+
+    fn dag_2_precisions_lut_chain(
+        depth: u64,
+        precision_low: Precision,
+        precision_high: Precision,
+        weight_low: i64,
+        weight_high: i64,
+    ) -> unparametrized::OperationDag {
+        let shape = Shape::number();
+        let mut dag = unparametrized::OperationDag::new();
+        let weights_low = Weights::number(weight_low);
+        let weights_high = Weights::number(weight_high);
+        let mut last_val_low = dag.add_input(precision_low, &shape);
+        let mut last_val_high = dag.add_input(precision_high, &shape);
+        for _i in 0..depth {
+            let dot_low = dag.add_dot([last_val_low], &weights_low);
+            last_val_low = dag.add_lut(dot_low, FunctionTable::UNKWOWN, precision_low);
+            let dot_high = dag.add_dot([last_val_high], &weights_high);
+            last_val_high = dag.add_lut(dot_high, FunctionTable::UNKWOWN, precision_high);
+        }
+        dag
+    }
+
+    #[allow(clippy::unnecessary_cast)] // clippy bug refusing as Precision on const
+    #[test]
+    fn test_global_p_error_dominating_lut() {
+        let depth = 128;
+        let weights_low = 1;
+        let weights_high = 1;
+        let precision_low = 6 as Precision;
+        let precision_high = 8 as Precision;
+        let dag = dag_2_precisions_lut_chain(
+            depth,
+            precision_low,
+            precision_high,
+            weights_low,
+            weights_high,
+        );
+        let sol = optimize(&dag).best_solution.unwrap();
+        // the 2 first luts and low precision/weight luts have little impact on error probability
+        let nb_dominating_lut = depth - 1;
+        let approx_global_p_error = local_to_approx_global_p_error(sol.p_error, nb_dominating_lut);
+        // errors rate is approximated accurately
+        approx::assert_relative_eq!(
+            sol.global_p_error,
+            approx_global_p_error,
+            max_relative = 1e-01
+        );
+    }
+
+    #[allow(clippy::unnecessary_cast)] // clippy bug refusing as Precision on const
+    #[test]
+    fn test_global_p_error_non_dominating_lut() {
+        let depth = 128;
+        let weights_low = 1024 * 2130;
+        let weights_high = 1;
+        let precision_low = 6 as Precision;
+        let precision_high = 8 as Precision;
+        let dag = dag_2_precisions_lut_chain(
+            depth,
+            precision_low,
+            precision_high,
+            weights_low,
+            weights_high,
+        );
+        let sol = optimize(&dag).best_solution.unwrap();
+        // all intern luts have an impact on error probability almost equaly
+        let nb_dominating_lut = (2 * depth) - 1;
+        let approx_global_p_error = local_to_approx_global_p_error(sol.p_error, nb_dominating_lut);
+        // errors rate is approximated accurately
+        approx::assert_relative_eq!(
+            sol.global_p_error,
+            approx_global_p_error,
+            max_relative = 0.05
+        );
+    }
+
+    fn circuit_with_rounded_lut(
+        rounded_precision: Precision,
+        precision: Precision,
+        weight: i64,
+    ) -> unparametrized::OperationDag {
+        // circuit with intermediate high precision in levelled op
+        let shape = Shape::number();
+        let mut dag = unparametrized::OperationDag::new();
+        let weight = Weights::number(weight);
+        let val = dag.add_input(precision, shape);
+        let lut1 = dag.add_rounded_lut(val, FunctionTable::UNKWOWN, rounded_precision, precision);
+        let dot = dag.add_dot([lut1], weight);
+        let _lut2 = dag.add_rounded_lut(
+            dot,
+            FunctionTable::UNKWOWN,
+            rounded_precision,
+            rounded_precision,
+        );
+        dag
+    }
+
+    fn check_global_p_error_rounded_lut(
+        precision: Precision,
+        rounded_precision: Precision,
+        weight: i64,
+        check_linear_speedup: bool,
+    ) {
+        let dag_no_rounded = circuit_with_rounded_lut(precision, precision, weight);
+        let dag_rounded = circuit_with_rounded_lut(rounded_precision, precision, weight);
+        let dag_reduced = circuit_with_rounded_lut(rounded_precision, rounded_precision, weight);
+        let best_reduced = optimize(&dag_reduced).best_solution.unwrap();
+        let best_rounded = optimize(&dag_rounded).best_solution.unwrap();
+        let best_no_rounded_complexity = optimize(&dag_no_rounded)
+            .best_solution
+            .map_or(f64::INFINITY, |s| s.complexity);
+        // println!("Slowdown acc {rounded_precision} -> {precision}, {best_rounded.complexity/best_reduced.complexity}");
+        // println!("Speedup tlu {precision} -> {rounded_precision}, {best_no_rounded_complexity/best_rounded.complexity}");
+        if weight == 0 && precision - rounded_precision <= 4
+            || weight == 16 && precision - rounded_precision <= 3
+        {
+            // linear slowdown with almost no margin
+            assert!(
+                best_rounded.complexity
+                    <= best_reduced.complexity
+                        * (1.0 + 1.01 * (precision - rounded_precision) as f64)
+            );
+        } else if precision - rounded_precision <= 4 {
+            // linear slowdown with margin
+            assert!(
+                best_rounded.complexity
+                    <= best_reduced.complexity
+                        * (1.0 + 1.5 * (precision - rounded_precision) as f64)
+            );
+        } else if precision != rounded_precision {
+            // slowdown
+            assert!(best_reduced.complexity < best_rounded.complexity);
+        }
+        // linear speedup
+        if check_linear_speedup {
+            assert!(
+                best_rounded.complexity * (precision - rounded_precision) as f64
+                    <= best_no_rounded_complexity
+            );
+        }
+    }
+
+    #[allow(clippy::unnecessary_cast)] // clippy bug refusing as Precision on const
+    #[test]
+    fn test_global_p_error_rounded_lut() {
+        let precision = 8 as Precision;
+        for rounded_precision in 4..9 {
+            check_global_p_error_rounded_lut(precision, rounded_precision, 1, true);
+        }
+    }
+
+    #[allow(clippy::unnecessary_cast)] // clippy bug refusing as Precision on const
+    #[test]
+    fn test_global_p_error_increased_accumulator() {
+        let rounded_precision = 8 as Precision;
+        for precision in [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] {
+            for weight in [1, 2, 4, 8, 16, 32, 64, 128] {
+                println!("{precision} {weight}");
+                check_global_p_error_rounded_lut(precision, rounded_precision, weight, false);
+            }
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/solo_key/optimize_generic.rs

@@ -0,0 +1,106 @@
+use crate::dag::operator::Precision;
+use crate::dag::unparametrized::OperationDag;
+use crate::noise_estimator::p_error::repeat_p_error;
+use crate::optimization::atomic_pattern::Solution as WpSolution;
+use crate::optimization::config::{Config, SearchSpace};
+use crate::optimization::dag::solo_key::{analyze, optimize};
+use crate::optimization::decomposition::PersistDecompCaches;
+use crate::optimization::wop_atomic_pattern::optimize::optimize_one as wop_optimize;
+use crate::optimization::wop_atomic_pattern::Solution as WopSolution;
+
+use super::analyze::has_round;
+
+pub enum Solution {
+    WpSolution(WpSolution),
+    WopSolution(WopSolution),
+}
+
+impl Solution {
+    fn complexity(&self) -> f64 {
+        match self {
+            Self::WpSolution(v) => v.complexity,
+            Self::WopSolution(v) => v.complexity,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Encoding {
+    Auto,
+    Native,
+    Crt,
+}
+
+fn max_precision(dag: &OperationDag) -> Precision {
+    dag.out_precisions.iter().copied().max().unwrap_or(0)
+}
+
+fn updated_global_p_error_and_comlexity(nb_luts: u64, sol: WopSolution) -> WopSolution {
+    let global_p_error = repeat_p_error(sol.p_error, nb_luts);
+    let complexity = nb_luts as f64 * sol.complexity;
+    WopSolution {
+        complexity,
+        global_p_error,
+        ..sol
+    }
+}
+
+fn best_complexity_solution(native: Option<Solution>, crt: Option<Solution>) -> Option<Solution> {
+    match (&native, &crt) {
+        (Some(s_native), Some(s_crt)) => {
+            // crt has 0 complexity in no lut case
+            // so we always select native in this case
+            if s_native.complexity() <= s_crt.complexity() || s_crt.complexity() == 0.0 {
+                native
+            } else {
+                crt
+            }
+        }
+        (Some(_), None) => native,
+        (None, Some(_)) => crt,
+        (None, None) => None,
+    }
+}
+
+fn optimize_with_wop_pbs(
+    dag: &OperationDag,
+    config: Config,
+    search_space: &SearchSpace,
+    default_log_norm2_woppbs: f64,
+    caches: &PersistDecompCaches,
+) -> Option<WopSolution> {
+    if has_round(dag) {
+        return None;
+    }
+    let max_precision = max_precision(dag);
+    let nb_luts = analyze::lut_count_from_dag(dag);
+    let worst_log_norm = analyze::worst_log_norm_for_wop(dag);
+    let log_norm = default_log_norm2_woppbs.min(worst_log_norm);
+    wop_optimize(max_precision as u64, config, log_norm, search_space, caches)
+        .best_solution
+        .map(|sol| updated_global_p_error_and_comlexity(nb_luts, sol))
+}
+
+pub fn optimize(
+    dag: &OperationDag,
+    config: Config,
+    search_space: &SearchSpace,
+    encoding: Encoding,
+    default_log_norm2_woppbs: f64,
+    caches: &PersistDecompCaches,
+) -> Option<Solution> {
+    let native = || {
+        optimize::optimize(dag, config, search_space, caches)
+            .best_solution
+            .map(Solution::WpSolution)
+    };
+    let crt = || {
+        optimize_with_wop_pbs(dag, config, search_space, default_log_norm2_woppbs, caches)
+            .map(Solution::WopSolution)
+    };
+    match encoding {
+        Encoding::Auto => best_complexity_solution(native(), crt()),
+        Encoding::Native => native(),
+        Encoding::Crt => crt(),
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/dag/solo_key/symbolic_variance.rs

@@ -0,0 +1,146 @@
+use std::iter::Sum;
+
+/**
+ * A variance that is represented as a linear combination of base variances.
+ * Only the linear coefficient are known.
+ * The base variances are unknown.
+ *
+ * Only 2 base variances are possible in the solo key setup:
+ *  - from input,
+ *  - or from lut output.
+ *
+ * We only kown that the first one is lower or equal to the second one.
+ * Each linear coefficient is a variance factor.
+ * There are homogenious to squared weight (or summed square weights or squared norm2).
+ */
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct SymbolicVariance {
+    pub lut_coeff: f64,
+    pub input_coeff: f64,
+    // variance = vf.lut_coeff * lut_out_noise
+    //          + vf.input_coeff * input_out_noise
+    // E.g. variance(dot([lut, input], [3, 4])) = VariancesFactors {lut_coeff:9, input_coeff: 16}
+
+    // NOTE: lut_base_noise is the first field since it has higher impact,
+    // see pareto sorting and dominate_or_equal
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VarianceOrigin {
+    Input,
+    Lut,
+    Mixed,
+}
+
+impl std::ops::Add for SymbolicVariance {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            lut_coeff: self.lut_coeff + rhs.lut_coeff,
+            input_coeff: self.input_coeff + rhs.input_coeff,
+        }
+    }
+}
+
+impl std::ops::AddAssign for SymbolicVariance {
+    fn add_assign(&mut self, rhs: Self) {
+        self.lut_coeff += rhs.lut_coeff;
+        self.input_coeff += rhs.input_coeff;
+    }
+}
+
+impl Sum for SymbolicVariance {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let mut accumulator = Self::ZERO;
+
+        for item in iter {
+            accumulator += item;
+        }
+
+        accumulator
+    }
+}
+
+impl std::ops::Mul<f64> for SymbolicVariance {
+    type Output = Self;
+    fn mul(self, sq_weight: f64) -> Self {
+        Self {
+            input_coeff: self.input_coeff * sq_weight,
+            lut_coeff: self.lut_coeff * sq_weight,
+        }
+    }
+}
+
+impl std::ops::Mul<u64> for SymbolicVariance {
+    type Output = Self;
+    fn mul(self, sq_weight: u64) -> Self {
+        self * sq_weight as f64
+    }
+}
+
+impl std::ops::Mul<i64> for SymbolicVariance {
+    type Output = Self;
+    fn mul(self, sq_weight: i64) -> Self {
+        self * sq_weight as f64
+    }
+}
+
+impl SymbolicVariance {
+    pub const ZERO: Self = Self {
+        input_coeff: 0.0,
+        lut_coeff: 0.0,
+    };
+    pub const INPUT: Self = Self {
+        input_coeff: 1.0,
+        lut_coeff: 0.0,
+    };
+    pub const LUT: Self = Self {
+        input_coeff: 0.0,
+        lut_coeff: 1.0,
+    };
+
+    pub fn origin(&self) -> VarianceOrigin {
+        if self.lut_coeff == 0.0 {
+            VarianceOrigin::Input
+        } else if self.input_coeff == 0.0 {
+            VarianceOrigin::Lut
+        } else {
+            VarianceOrigin::Mixed
+        }
+    }
+
+    pub fn manp_to_variance_factor(manp: f64) -> f64 {
+        manp * manp
+    }
+
+    pub fn dominate_or_equal(&self, other: &Self) -> bool {
+        let extra_other_minimal_base_noise = 0.0_f64.max(other.input_coeff - self.input_coeff);
+        other.lut_coeff + extra_other_minimal_base_noise <= self.lut_coeff
+    }
+
+    pub fn eval(&self, minimal_base_noise: f64, lut_base_noise: f64) -> f64 {
+        minimal_base_noise * self.input_coeff + lut_base_noise * self.lut_coeff
+    }
+
+    pub fn reduce_to_pareto_front(mut vfs: Vec<Self>) -> Vec<Self> {
+        if vfs.is_empty() {
+            return vec![];
+        }
+        vfs.sort_by(
+            // bigger first
+            |a, b| b.partial_cmp(a).unwrap(),
+        );
+        // Due to the special domination nature, this can be done in one pass
+        let mut dominator = vfs[0];
+        let mut pareto = vec![dominator];
+        for &vf in vfs.iter().skip(1) {
+            if dominator.dominate_or_equal(&vf) {
+                continue;
+            }
+            dominator = vf;
+            pareto.push(vf);
+        }
+        pareto
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/circuit_bootstrap.rs

@@ -0,0 +1,156 @@
+use std::sync::Arc;
+
+use concrete_cpu_noise_model::gaussian_noise::noise::cmux::variance_cmux;
+use serde::{Deserialize, Serialize};
+
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+use crate::parameters::{BrDecompositionParameters, CmuxParameters, GlweParameters};
+use crate::utils::cache::ephemeral::{CacheHashMap, EphemeralCache};
+use crate::utils::cache::persistent::{default_cache_dir, PersistentCacheHashMap};
+use crate::utils::square;
+
+use super::common::VERSION;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct CbComplexityNoise {
+    pub decomp: BrDecompositionParameters,
+    pub complexity_one_cmux_hp: f64,
+    pub complexity_one_ggsw_to_fft: f64,
+    pub variance_bias: f64,
+    pub variance_ggsw_factor: f64,
+}
+
+impl CbComplexityNoise {
+    pub fn variance_from_ggsw(&self, variance_ggsw: f64) -> f64 {
+        self.variance_bias + self.variance_ggsw_factor * variance_ggsw
+    }
+}
+
+/* This is stricly variance decreasing and strictly complexity increasing */
+pub fn pareto_quantities(
+    complexity_model: &dyn ComplexityModel,
+    ciphertext_modulus_log: u32,
+    glwe_params: GlweParameters,
+) -> Vec<CbComplexityNoise> {
+    assert!(ciphertext_modulus_log == 64);
+    let cmux_param = |level, log2_base| {
+        let br_decomposition_parameter = BrDecompositionParameters { level, log2_base };
+        CmuxParameters {
+            br_decomposition_parameter,
+            output_glwe_params: glwe_params,
+        }
+    };
+    let mut quantities = Vec::with_capacity(64);
+    let max_level = ciphertext_modulus_log as u64;
+    for level in 1..=max_level {
+        // detect increasing noise
+        for log2_base in 1..=(max_level / level) {
+            let params = cmux_param(level, log2_base);
+            // Hybrid packing
+            let complexity_one_cmux_hp =
+                complexity_model.cmux_complexity(params, ciphertext_modulus_log);
+
+            let f_glwe_poly_size = glwe_params.polynomial_size() as f64;
+
+            let f_glwe_size = (glwe_params.glwe_dimension + 1) as f64;
+
+            let complexity_one_ggsw_to_fft = square(f_glwe_size)
+                * level as f64
+                * complexity_model.fft_complexity(f_glwe_poly_size, ciphertext_modulus_log);
+
+            // Compute bias and slove for variance_one_external_product_for_cmux_tree_bias
+            let variance = |variance_bsk| {
+                variance_cmux(
+                    glwe_params.glwe_dimension,
+                    glwe_params.polynomial_size(),
+                    log2_base,
+                    level,
+                    ciphertext_modulus_log,
+                    variance_bsk,
+                )
+            };
+            let variance_at_0 = variance(0.0);
+            let variance_at_1 = variance(1.0);
+            let variance_one_external_product_for_cmux_tree_bias = variance_at_0;
+            let variance_one_external_product_for_cmux_tree_slope = variance_at_1 - variance_at_0;
+
+            quantities.push(CbComplexityNoise {
+                decomp: params.br_decomposition_parameter,
+                complexity_one_cmux_hp,
+                complexity_one_ggsw_to_fft,
+                variance_bias: variance_one_external_product_for_cmux_tree_bias,
+                variance_ggsw_factor: variance_one_external_product_for_cmux_tree_slope,
+            });
+        }
+    }
+    quantities
+}
+
+pub type Cache = CacheHashMap<GlweParameters, CbPareto>;
+
+impl Cache {
+    pub fn pareto_quantities(&mut self, glwe_params: GlweParameters) -> &CbPareto {
+        self.get(glwe_params)
+    }
+}
+
+pub type PersistDecompCache = PersistentCacheHashMap<GlweParameters, CbPareto>;
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct CbPareto {
+    pub pareto: Vec<CbComplexityNoise>,
+    pub lower_pareto_cb_bias: f64,
+    pub lower_pareto_cb_slope: f64,
+    pub lower_bound_cost_cb_complexity_1_cmux_hp: f64,
+    pub lower_bound_cost_cb_complexity_1_ggsw_to_fft: f64,
+}
+
+pub fn cache(
+    security_level: u64,
+    processing_unit: config::ProcessingUnit,
+    complexity_model: Arc<dyn ComplexityModel>,
+) -> PersistDecompCache {
+    let cache_dir: String = default_cache_dir();
+    let ciphertext_modulus_log = 64;
+    let hardware = processing_unit.br_to_string();
+    let path =
+        format!("{cache_dir}/cb-decomp-{hardware}-{ciphertext_modulus_log}-{security_level}");
+    let function = move |glwe_params| {
+        let pareto = pareto_quantities(
+            complexity_model.as_ref(),
+            ciphertext_modulus_log,
+            glwe_params,
+        );
+
+        let lower_pareto_cb_bias = pareto
+            .iter()
+            .map(|cb| cb.variance_bias)
+            .reduce(f64::min)
+            .unwrap();
+        let lower_pareto_cb_slope = pareto
+            .iter()
+            .map(|cb| cb.variance_ggsw_factor)
+            .reduce(f64::min)
+            .unwrap();
+        let lower_bound_cost_cb_complexity_1_cmux_hp = pareto
+            .iter()
+            .map(|cb| cb.complexity_one_cmux_hp)
+            .reduce(f64::min)
+            .unwrap();
+        let lower_bound_cost_cb_complexity_1_ggsw_to_fft = pareto
+            .iter()
+            .map(|cb| cb.complexity_one_ggsw_to_fft)
+            .reduce(f64::min)
+            .unwrap();
+
+        CbPareto {
+            pareto,
+            lower_pareto_cb_bias,
+            lower_pareto_cb_slope,
+            lower_bound_cost_cb_complexity_1_cmux_hp,
+            lower_bound_cost_cb_complexity_1_ggsw_to_fft,
+        }
+    };
+    PersistentCacheHashMap::new_no_read(&path, VERSION, function)
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/cmux.rs

@@ -0,0 +1,134 @@
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+use crate::parameters::{BrDecompositionParameters, CmuxParameters, GlweParameters};
+use crate::utils::cache::ephemeral::{CacheHashMap, EphemeralCache};
+use crate::utils::cache::persistent::{default_cache_dir, PersistentCacheHashMap};
+use concrete_cpu_noise_model::gaussian_noise::noise::cmux::variance_cmux;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use super::common::VERSION;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct CmuxComplexityNoise {
+    pub decomp: BrDecompositionParameters,
+    pub complexity: f64,
+    pub noise: f64,
+}
+
+impl CmuxComplexityNoise {
+    pub fn complexity_br(&self, in_lwe_dim: u64) -> f64 {
+        in_lwe_dim as f64 * self.complexity
+    }
+    pub fn noise_br(&self, in_lwe_dim: u64) -> f64 {
+        in_lwe_dim as f64 * self.noise
+    }
+}
+
+/* This is stricly variance decreasing and strictly complexity increasing */
+pub fn pareto_quantities(
+    complexity_model: &dyn ComplexityModel,
+    ciphertext_modulus_log: u32,
+    security_level: u64,
+    glwe_params: GlweParameters,
+) -> Vec<CmuxComplexityNoise> {
+    assert!(ciphertext_modulus_log == 64);
+
+    let variance_bsk = glwe_params.minimal_variance(ciphertext_modulus_log, security_level);
+
+    let mut quantities = Vec::with_capacity(ciphertext_modulus_log as usize);
+    let mut increasing_complexity = 0.0;
+    let mut decreasing_variance = f64::INFINITY;
+    let mut counting_no_progress = 0;
+
+    let mut prev_best_log2_base = ciphertext_modulus_log as u64;
+
+    for level in 1..=ciphertext_modulus_log as u64 {
+        // detect increasing noise
+        let mut level_decreasing_base_noise = f64::INFINITY;
+        let mut best_log2_base = 0_u64;
+        // we know a max is between 1 and prev_best_log2_base
+        // and the curve has only 1 maximum close to prev_best_log2_base
+        // so we start on prev_best_log2_base
+        let range = (1..=prev_best_log2_base).rev();
+
+        for log2_base in range {
+            let base_noise = variance_cmux(
+                glwe_params.glwe_dimension,
+                glwe_params.polynomial_size(),
+                log2_base,
+                level,
+                ciphertext_modulus_log,
+                variance_bsk,
+            );
+            if base_noise > level_decreasing_base_noise {
+                break;
+            }
+            level_decreasing_base_noise = base_noise;
+            best_log2_base = log2_base;
+        }
+        prev_best_log2_base = best_log2_base;
+        if decreasing_variance < level_decreasing_base_noise {
+            // the current case is dominated
+            if best_log2_base == 1 {
+                counting_no_progress += 1;
+                if counting_no_progress > 16 {
+                    break;
+                }
+            }
+            continue;
+        }
+
+        let br_decomposition_parameter = BrDecompositionParameters {
+            level,
+            log2_base: best_log2_base,
+        };
+        let params = CmuxParameters {
+            br_decomposition_parameter,
+            output_glwe_params: glwe_params,
+        };
+
+        let complexity = complexity_model.cmux_complexity(params, ciphertext_modulus_log);
+
+        quantities.push(CmuxComplexityNoise {
+            decomp: params.br_decomposition_parameter,
+            noise: level_decreasing_base_noise,
+            complexity,
+        });
+        assert!(increasing_complexity < complexity);
+        increasing_complexity = complexity;
+        decreasing_variance = level_decreasing_base_noise;
+    }
+    quantities
+}
+
+pub type Cache = CacheHashMap<GlweParameters, Vec<CmuxComplexityNoise>>;
+
+impl Cache {
+    pub fn pareto_quantities(&mut self, glwe_params: GlweParameters) -> &[CmuxComplexityNoise] {
+        self.get(glwe_params)
+    }
+}
+
+pub type PersistDecompCache = PersistentCacheHashMap<GlweParameters, Vec<CmuxComplexityNoise>>;
+
+pub fn cache(
+    security_level: u64,
+    processing_unit: config::ProcessingUnit,
+    complexity_model: Arc<dyn ComplexityModel>,
+) -> PersistDecompCache {
+    let cache_dir: String = default_cache_dir();
+    let ciphertext_modulus_log = 64;
+    let hardware = processing_unit.br_to_string();
+    let path = format!("{cache_dir}/cmux-decomp-{hardware}-64-{security_level}");
+
+    let function = move |glwe_params: GlweParameters| {
+        pareto_quantities(
+            complexity_model.as_ref(),
+            ciphertext_modulus_log,
+            security_level,
+            glwe_params,
+        )
+    };
+    PersistentCacheHashMap::new_no_read(&path, VERSION, function)
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/common.rs

@@ -0,0 +1,5 @@
+use crate::parameters::GlweParameters;
+
+pub type MacroParam = (GlweParameters, u64);
+
+pub const VERSION: u64 = 3;

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/keyswitch.rs

@@ -0,0 +1,141 @@
+use super::common::VERSION;
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+use crate::parameters::{KeyswitchParameters, KsDecompositionParameters, LweDimension};
+use crate::utils::cache::ephemeral::{CacheHashMap, EphemeralCache};
+use crate::utils::cache::persistent::{default_cache_dir, PersistentCacheHashMap};
+use concrete_cpu_noise_model::gaussian_noise::noise::keyswitch_one_bit::variance_keyswitch_one_bit;
+use concrete_security_curves::gaussian::security::minimal_variance_lwe;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct KsComplexityNoise {
+    pub decomp: KsDecompositionParameters,
+    pub complexity_bias: f64,
+    pub complexity_slope: f64,
+    pub noise: f64,
+}
+
+impl KsComplexityNoise {
+    pub fn complexity(&self, in_lwe_dim: u64) -> f64 {
+        self.complexity_bias + in_lwe_dim as f64 * self.complexity_slope
+    }
+    pub fn noise(&self, in_lwe_dim: u64) -> f64 {
+        in_lwe_dim as f64 * self.noise
+    }
+}
+
+/* This is stricly variance decreasing and strictly complexity increasing */
+pub fn pareto_quantities(
+    complexity_model: &dyn ComplexityModel,
+    ciphertext_modulus_log: u32,
+    security_level: u64,
+    internal_dim: u64,
+) -> Vec<KsComplexityNoise> {
+    assert!(ciphertext_modulus_log == 64);
+    let variance_ksk = minimal_variance_lwe(internal_dim, ciphertext_modulus_log, security_level);
+
+    let mut quantities = Vec::with_capacity(64);
+    let mut increasing_complexity_slope = 0.0;
+    let mut decreasing_variance = f64::INFINITY;
+    let mut counting_no_progress = 0;
+    let mut prev_best_log2_base = ciphertext_modulus_log as u64;
+
+    for level in 1..=ciphertext_modulus_log as u64 {
+        // detect increasing noise
+        let mut level_decreasing_base_noise = f64::INFINITY;
+        let mut best_log2_base = 0_u64;
+
+        // we know a max is between 1 and prev_best_log2_base
+        // and the curve has only 1 maximum close to prev_best_log2_base
+        // so we start on prev_best_log2_base
+        let range = (1..=prev_best_log2_base).rev();
+
+        for log2_base in range {
+            let noise_keyswitch =
+                variance_keyswitch_one_bit(log2_base, level, ciphertext_modulus_log, variance_ksk);
+            if noise_keyswitch > level_decreasing_base_noise {
+                break;
+            }
+            level_decreasing_base_noise = noise_keyswitch;
+            best_log2_base = log2_base;
+        }
+        prev_best_log2_base = best_log2_base;
+        if decreasing_variance < level_decreasing_base_noise {
+            // the current case is dominated
+            if best_log2_base == 1 {
+                counting_no_progress += 1;
+                if counting_no_progress > 16 {
+                    break;
+                }
+            }
+            continue;
+        }
+
+        let decomp = KsDecompositionParameters {
+            level,
+            log2_base: best_log2_base,
+        };
+
+        let complexity_at = |in_lwe_dim| {
+            complexity_model.ks_complexity(
+                KeyswitchParameters {
+                    input_lwe_dimension: LweDimension(in_lwe_dim),
+                    output_lwe_dimension: LweDimension(internal_dim),
+                    ks_decomposition_parameter: decomp,
+                },
+                ciphertext_modulus_log,
+            )
+        };
+
+        let complexity_at_0 = complexity_at(0);
+        let complexity_at_1 = complexity_at(1);
+
+        let complexity_bias = complexity_at_0;
+
+        let complexity_slope = complexity_at_1 - complexity_at_0;
+
+        quantities.push(KsComplexityNoise {
+            decomp,
+            noise: level_decreasing_base_noise,
+            complexity_slope,
+            complexity_bias,
+        });
+        assert!(increasing_complexity_slope < complexity_slope);
+        increasing_complexity_slope = complexity_slope;
+        decreasing_variance = level_decreasing_base_noise;
+    }
+    quantities
+}
+
+pub type Cache = CacheHashMap<u64, Vec<KsComplexityNoise>>;
+
+impl Cache {
+    pub fn pareto_quantities(&mut self, internal_dim: u64) -> &[KsComplexityNoise] {
+        self.get(internal_dim)
+    }
+}
+
+pub type PersistDecompCache = PersistentCacheHashMap<u64, Vec<KsComplexityNoise>>;
+
+pub fn cache(
+    security_level: u64,
+    processing_unit: config::ProcessingUnit,
+    complexity_model: Arc<dyn ComplexityModel>,
+) -> PersistDecompCache {
+    let cache_dir: String = default_cache_dir();
+    let ciphertext_modulus_log = 64;
+    let hardware = processing_unit.ks_to_string();
+    let path = format!("{cache_dir}/ks-decomp-{hardware}-64-{security_level}");
+
+    let function = move |internal_dim: u64| {
+        pareto_quantities(
+            complexity_model.as_ref(),
+            ciphertext_modulus_log,
+            security_level,
+            internal_dim,
+        )
+    };
+    PersistentCacheHashMap::new_no_read(&path, VERSION, function)
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/mod.rs

@@ -0,0 +1,86 @@
+pub mod circuit_bootstrap;
+pub mod cmux;
+pub mod common;
+pub mod keyswitch;
+pub mod pp_switch;
+
+pub use common::MacroParam;
+
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+
+use std::sync::Arc;
+
+pub struct PersistDecompCaches {
+    pub ks: keyswitch::PersistDecompCache,
+    pub cmux: cmux::PersistDecompCache,
+    pub pp: pp_switch::PersistDecompCache,
+    pub cb: circuit_bootstrap::PersistDecompCache,
+    pub cache_on_disk: bool,
+}
+
+pub struct DecompCaches {
+    pub cmux: cmux::Cache,
+    pub keyswitch: keyswitch::Cache,
+    pub pp_switch: pp_switch::Cache,
+    pub cb_pbs: circuit_bootstrap::Cache,
+}
+
+pub fn cache(
+    security_level: u64,
+    processing_unit: config::ProcessingUnit,
+    complexity_model: Option<Arc<dyn ComplexityModel>>,
+    cache_on_disk: bool,
+) -> PersistDecompCaches {
+    PersistDecompCaches::new(
+        security_level,
+        processing_unit,
+        complexity_model,
+        cache_on_disk,
+    )
+}
+
+impl PersistDecompCaches {
+    pub fn new(
+        security_level: u64,
+        processing_unit: config::ProcessingUnit,
+        complexity_model: Option<Arc<dyn ComplexityModel>>,
+        cache_on_disk: bool,
+    ) -> Self {
+        let complexity_model =
+            complexity_model.unwrap_or_else(|| processing_unit.complexity_model());
+        let res = Self {
+            ks: keyswitch::cache(security_level, processing_unit, complexity_model.clone()),
+            cmux: cmux::cache(security_level, processing_unit, complexity_model.clone()),
+            pp: pp_switch::cache(security_level, processing_unit, complexity_model.clone()),
+            cb: circuit_bootstrap::cache(security_level, processing_unit, complexity_model),
+            cache_on_disk,
+        };
+        if cache_on_disk {
+            res.ks.read();
+            res.cmux.read();
+            res.pp.read();
+            res.cb.read();
+        }
+        res
+    }
+
+    pub fn backport(&self, cache: DecompCaches) {
+        if !self.cache_on_disk {
+            return;
+        }
+        self.ks.backport(cache.keyswitch);
+        self.cmux.backport(cache.cmux);
+        self.pp.backport(cache.pp_switch);
+        self.cb.backport(cache.cb_pbs);
+    }
+
+    pub fn caches(&self) -> DecompCaches {
+        DecompCaches {
+            cmux: self.cmux.cache(),
+            keyswitch: self.ks.cache(),
+            pp_switch: self.pp.cache(),
+            cb_pbs: self.cb.cache(),
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/decomposition/pp_switch.rs

@@ -0,0 +1,128 @@
+use super::common::VERSION;
+use crate::computing_cost::complexity_model::ComplexityModel;
+use crate::config;
+use crate::parameters::{
+    BrDecompositionParameters, GlweParameters, KeyswitchParameters, KsDecompositionParameters,
+    LweDimension,
+};
+use crate::utils::cache::ephemeral::{CacheHashMap, EphemeralCache};
+use crate::utils::cache::persistent::{default_cache_dir, PersistentCacheHashMap};
+use concrete_cpu_noise_model::gaussian_noise::noise::private_packing_keyswitch::estimate_packing_private_keyswitch;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+pub struct PpSwitchComplexityNoise {
+    pub decomp: BrDecompositionParameters,
+    pub complexity: f64,
+    pub noise: f64,
+}
+
+pub type Cache = CacheHashMap<GlweParameters, Vec<PpSwitchComplexityNoise>>;
+
+impl Cache {
+    pub fn pareto_quantities(&mut self, glwe_params: GlweParameters) -> &[PpSwitchComplexityNoise] {
+        self.get(glwe_params)
+    }
+}
+
+pub type PersistDecompCache = PersistentCacheHashMap<GlweParameters, Vec<PpSwitchComplexityNoise>>;
+
+pub fn pareto_quantities(
+    complexity_model: &dyn ComplexityModel,
+    ciphertext_modulus_log: u32,
+    security_level: u64,
+    glwe_params: GlweParameters,
+) -> Vec<PpSwitchComplexityNoise> {
+    let variance_bsk = glwe_params.minimal_variance(ciphertext_modulus_log, security_level);
+    let mut quantities = Vec::with_capacity(64);
+    let mut increasing_complexity = 0.0;
+    let mut decreasing_variance = f64::INFINITY;
+    let mut counting_no_progress = 0;
+
+    let max_level = ciphertext_modulus_log as u64;
+
+    let mut prev_best_log2_base = ciphertext_modulus_log as u64;
+    for level in 1..=max_level {
+        // detect increasing noise
+        let mut level_decreasing_base_noise = f64::INFINITY;
+        let mut best_log2_base = 0_u64;
+
+        // we know a max is between 1 and prev_best_log2_base
+        // and the curve has only 1 maximum close to prev_best_log2_base
+        // so we start on prev_best_log2_base
+        let max_log2_base = prev_best_log2_base.min(max_level / level);
+        for log2_base in (1..=max_log2_base).rev() {
+            let variance_private_packing_ks = estimate_packing_private_keyswitch(
+                0.,
+                variance_bsk,
+                log2_base,
+                level,
+                glwe_params.glwe_dimension,
+                glwe_params.polynomial_size(),
+                ciphertext_modulus_log,
+            );
+            if variance_private_packing_ks > level_decreasing_base_noise {
+                break;
+            }
+            level_decreasing_base_noise = variance_private_packing_ks;
+            best_log2_base = log2_base;
+        }
+        prev_best_log2_base = best_log2_base;
+        if decreasing_variance < level_decreasing_base_noise {
+            // the current case is dominated
+            if best_log2_base == 1 {
+                counting_no_progress += 1;
+                if counting_no_progress > 16 {
+                    break;
+                }
+            }
+            continue;
+        }
+        let sample_extract_lwe_dimension = LweDimension(glwe_params.sample_extract_lwe_dimension());
+        let ppks_parameter_complexity = KeyswitchParameters {
+            input_lwe_dimension: sample_extract_lwe_dimension,
+            output_lwe_dimension: sample_extract_lwe_dimension,
+            ks_decomposition_parameter: KsDecompositionParameters {
+                level,
+                log2_base: best_log2_base,
+            },
+        };
+        let complexity_ppks =
+            complexity_model.ks_complexity(ppks_parameter_complexity, ciphertext_modulus_log);
+        let pp_ks_decomposition_parameter = BrDecompositionParameters {
+            level,
+            log2_base: best_log2_base,
+        };
+        quantities.push(PpSwitchComplexityNoise {
+            decomp: pp_ks_decomposition_parameter,
+            complexity: complexity_ppks,
+            noise: level_decreasing_base_noise,
+        });
+        assert!(increasing_complexity < complexity_ppks);
+        increasing_complexity = complexity_ppks;
+        decreasing_variance = level_decreasing_base_noise;
+    }
+    quantities
+}
+
+pub fn cache(
+    security_level: u64,
+    processing_unit: config::ProcessingUnit,
+    complexity_model: Arc<dyn ComplexityModel>,
+) -> PersistDecompCache {
+    let cache_dir: String = default_cache_dir();
+    let ciphertext_modulus_log = 64;
+    let hardware = processing_unit.br_to_string();
+    let path = format!("{cache_dir}/pp-decomp-{hardware}-64-{security_level}");
+
+    let function = move |glwe_params: GlweParameters| {
+        pareto_quantities(
+            complexity_model.as_ref(),
+            ciphertext_modulus_log,
+            security_level,
+            glwe_params,
+        )
+    };
+    PersistentCacheHashMap::new_no_read(&path, VERSION, function)
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/mod.rs

@@ -0,0 +1,5 @@
+pub mod atomic_pattern;
+pub mod config;
+pub mod dag;
+pub mod decomposition;
+pub mod wop_atomic_pattern;

compilers/concrete-optimizer/concrete-optimizer/src/optimization/wop_atomic_pattern/crt_decomposition.rs

@@ -0,0 +1,52 @@
+use crate::dag::operator::Precision;
+
+// Default heuristic to split in several word
+pub fn default_coprimes(precision: Precision) -> Result<Vec<u64>, String> {
+    Ok(match precision {
+        1 => vec![2],                         // 1 bit
+        2 => vec![4],                         // 2 bit
+        3 => vec![8],                         // 3 bit
+        4 | 5 => vec![2, 3, 7],               // 1,2,3 bits
+        6 => vec![2, 5, 7],                   // 1,3,3 bits
+        7 => vec![3, 7, 8],                   // 2,3,3 bits
+        8 => vec![5, 7, 8],                   // 3,3,3 bits
+        9 => vec![5, 7, 16],                  // 3,3,4 bits
+        10 => vec![7, 15, 16],                // 3,4,4 bits
+        11 => vec![13, 15, 16],               // 4,4,4 bits
+        12 => vec![7, 13, 15, 16],            // 3,4,4,4 bits
+        13 | 14 | 15 => vec![11, 13, 15, 16], // 4,4,4,4 bits
+        16 => vec![7, 8, 9, 11, 13],          // 4,4,4,4,4 bits
+        0 => return Err("Precision cannot be zero".into()),
+        _ => return Err("Precision is limited to 16-bits".into()),
+    })
+}
+
+#[allow(clippy::cast_sign_loss)]
+fn bitwidth(v: u64) -> Precision {
+    assert!(v > 0);
+    (v as f64).log2().ceil() as Precision
+}
+
+pub fn precisions_from_coprimes(coprimes: &[u64]) -> Vec<u64> {
+    coprimes
+        .iter()
+        .copied()
+        .map(|coprime| bitwidth(coprime) as u64)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_coprimes() {
+        for precision in 1..=16 {
+            let coprimes = default_coprimes(precision);
+            assert!(coprimes.is_ok());
+            let prod: u64 = coprimes.unwrap().iter().product();
+            println!("{precision} {prod}");
+            assert!((1 << precision) <= prod);
+        }
+        assert!(default_coprimes(17).is_err());
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/optimization/wop_atomic_pattern/mod.rs

@@ -0,0 +1,4 @@
+pub(crate) mod crt_decomposition;
+pub mod optimize;
+
+pub use optimize::Solution;

compilers/concrete-optimizer/concrete-optimizer/src/optimization/wop_atomic_pattern/optimize.rs

@@ -0,0 +1,533 @@
+use concrete_cpu_noise_model::gaussian_noise::conversion::variance_to_std_dev;
+use concrete_cpu_noise_model::gaussian_noise::noise::modulus_switching::estimate_modulus_switching_noise_with_binary_key;
+
+use super::crt_decomposition;
+use crate::dag::operator::Precision;
+use crate::noise_estimator::error::{
+    error_probability_of_sigma_scale, safe_variance_bound_product_1padbit,
+    sigma_scale_of_error_probability,
+};
+use crate::optimization::atomic_pattern;
+use crate::optimization::atomic_pattern::OptimizationDecompositionsConsts;
+
+use crate::optimization::config::{Config, SearchSpace};
+use crate::optimization::decomposition::circuit_bootstrap::{CbComplexityNoise, CbPareto};
+use crate::optimization::decomposition::cmux::CmuxComplexityNoise;
+use crate::optimization::decomposition::keyswitch::KsComplexityNoise;
+use crate::optimization::decomposition::pp_switch::PpSwitchComplexityNoise;
+use crate::optimization::decomposition::PersistDecompCaches;
+use crate::parameters::{BrDecompositionParameters, GlweParameters};
+use crate::utils::square;
+
+pub fn find_p_error(kappa: f64, variance_bound: f64, current_maximum_noise: f64) -> f64 {
+    let sigma = variance_to_std_dev(variance_bound) * kappa;
+    let sigma_scale = sigma / variance_to_std_dev(current_maximum_noise);
+    error_probability_of_sigma_scale(sigma_scale)
+}
+
+#[derive(Clone, Debug)]
+pub struct OptimizationState {
+    pub best_solution: Option<Solution>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Solution {
+    pub input_lwe_dimension: u64,
+    //n_big
+    pub internal_ks_output_lwe_dimension: u64,
+    //n_small
+    pub ks_decomposition_level_count: u64,
+    //l(KS)
+    pub ks_decomposition_base_log: u64,
+    //b(KS)
+    pub glwe_polynomial_size: u64,
+    //N
+    pub glwe_dimension: u64,
+    //k
+    pub br_decomposition_level_count: u64,
+    //l(BR)
+    pub br_decomposition_base_log: u64,
+    //b(BR)
+    pub complexity: f64,
+    pub noise_max: f64,
+    pub p_error: f64,
+    pub global_p_error: f64,
+    // error probability
+    pub cb_decomposition_level_count: u64,
+    pub cb_decomposition_base_log: u64,
+    pub crt_decomposition: Vec<u64>,
+    pub pp_decomposition_level_count: u64,
+    pub pp_decomposition_base_log: u64,
+}
+
+impl Solution {
+    pub fn init() -> Self {
+        Self {
+            input_lwe_dimension: 0,
+            internal_ks_output_lwe_dimension: 0,
+            ks_decomposition_level_count: 0,
+            ks_decomposition_base_log: 0,
+            glwe_polynomial_size: 0,
+            glwe_dimension: 0,
+            br_decomposition_level_count: 0,
+            br_decomposition_base_log: 0,
+            complexity: 0.,
+            noise_max: 0.0,
+            p_error: 0.0,
+            global_p_error: 0.0,
+            cb_decomposition_level_count: 0,
+            cb_decomposition_base_log: 0,
+            crt_decomposition: vec![],
+            pp_decomposition_level_count: 0,
+            pp_decomposition_base_log: 0,
+        }
+    }
+}
+
+impl From<Solution> for atomic_pattern::Solution {
+    fn from(sol: Solution) -> Self {
+        Self {
+            input_lwe_dimension: sol.input_lwe_dimension,
+            internal_ks_output_lwe_dimension: sol.internal_ks_output_lwe_dimension,
+            ks_decomposition_level_count: sol.ks_decomposition_level_count,
+            ks_decomposition_base_log: sol.ks_decomposition_base_log,
+            glwe_polynomial_size: sol.glwe_polynomial_size,
+            glwe_dimension: sol.glwe_dimension,
+            br_decomposition_level_count: sol.br_decomposition_level_count,
+            br_decomposition_base_log: sol.br_decomposition_base_log,
+            complexity: sol.complexity,
+            noise_max: sol.noise_max,
+            p_error: sol.p_error,
+            global_p_error: sol.global_p_error,
+        }
+    }
+}
+
+fn estimate_variance(
+    br_variance: f64,
+    pp_variance: f64,
+    cb_decomp: &CbComplexityNoise,
+    ks_variance: f64,
+    variance_modulus_switching: f64,
+    norm: f64,
+    precisions_sum: u64,
+    max_precision: u64,
+) -> f64 {
+    assert!(max_precision <= precisions_sum);
+    let variance_ggsw = pp_variance + br_variance / 2.;
+    let variance_coeff_1_cmux_tree =
+        square(norm)            // variance_coeff for the multisum
+        * (precisions_sum                    // for hybrid packing
+        << (2 * (max_precision - 1))) as f64 // for left shift
+    ;
+    let variance_one_external_product_for_cmux_tree = cb_decomp.variance_from_ggsw(variance_ggsw);
+    variance_modulus_switching
+        + variance_coeff_1_cmux_tree * variance_one_external_product_for_cmux_tree
+        + ks_variance
+}
+
+fn estimate_complexity(
+    glwe_params: &GlweParameters,
+    br_cost: f64,
+    pp_cost: f64,
+    cb_decomp: &CbComplexityNoise,
+    ks_cost: f64,
+    precisions_sum: u64,
+    nb_blocks: u64,
+    n_functions: u64,
+) -> f64 {
+    // Pbs dans BitExtract et Circuit BS et FP-KS (partagés)
+    // Hybrid packing
+    let cb_level = cb_decomp.decomp.level;
+    let complexity_1_cmux_hp = cb_decomp.complexity_one_cmux_hp;
+    let complexity_1_ggsw_to_fft = cb_decomp.complexity_one_ggsw_to_fft;
+    // BitExtract use br
+    let complexity_bit_extract_1_pbs = br_cost;
+    let complexity_bit_extract_wo_ks =
+        (precisions_sum - nb_blocks) as f64 * complexity_bit_extract_1_pbs;
+
+    // Hybrid packing
+    // Circuit bs: fp-ks
+    let complexity_ppks = pp_cost;
+    let complexity_all_ppks =
+        ((glwe_params.glwe_dimension + 1) * cb_level * precisions_sum) as f64 * complexity_ppks;
+
+    // Circuit bs: pbs
+    let complexity_all_pbs = (precisions_sum * cb_level) as f64 * br_cost;
+
+    let complexity_circuit_bs = complexity_all_pbs + complexity_all_ppks;
+
+    // Hybrid packing (Do we have 1 or 2 groups)
+    let log2_polynomial_size = glwe_params.log2_polynomial_size;
+    // Size of cmux_group, can be zero
+    let cmux_group_count = if precisions_sum > log2_polynomial_size {
+        2f64.powi((precisions_sum - log2_polynomial_size - 1) as i32)
+    } else {
+        0.0
+    };
+    let complexity_cmux_tree = cmux_group_count * complexity_1_cmux_hp;
+
+    let complexity_all_ggsw_to_fft = precisions_sum as f64 * complexity_1_ggsw_to_fft;
+
+    // Hybrid packing blind rotate
+    let complexity_g_br =
+        complexity_1_cmux_hp * u64::min(glwe_params.log2_polynomial_size, precisions_sum) as f64;
+
+    let complexity_hybrid_packing = complexity_cmux_tree + complexity_g_br;
+
+    let complexity_multi_hybrid_packing =
+        n_functions as f64 * complexity_hybrid_packing + complexity_all_ggsw_to_fft;
+
+    let complexity_all_ks = precisions_sum as f64 * ks_cost;
+
+    complexity_bit_extract_wo_ks
+        + complexity_circuit_bs
+        + complexity_multi_hybrid_packing
+        + complexity_all_ks
+}
+
+#[allow(clippy::too_many_lines)]
+fn update_state_with_best_decompositions(
+    state: &mut OptimizationState,
+    consts: &OptimizationDecompositionsConsts,
+    glwe_params: GlweParameters,
+    internal_dim: u64,
+    n_functions: u64,
+    partitionning: &[u64],
+    pareto_cmux: &[CmuxComplexityNoise],
+    pareto_keyswitch: &[KsComplexityNoise],
+    pp_switch: &[PpSwitchComplexityNoise],
+    pareto_cb: &CbPareto,
+) {
+    let ciphertext_modulus_log = consts.config.ciphertext_modulus_log;
+    let precisions_sum = partitionning.iter().copied().sum();
+    let max_precision = partitionning.iter().copied().max().unwrap();
+    let nb_blocks = partitionning.len() as u64;
+
+    let input_lwe_dimension = glwe_params.sample_extract_lwe_dimension();
+
+    let safe_variance_bound = consts.safe_variance;
+    let norm = consts.noise_factor;
+
+    let variance_modulus_switching = estimate_modulus_switching_noise_with_binary_key(
+        internal_dim,
+        glwe_params.log2_polynomial_size,
+        ciphertext_modulus_log,
+    );
+
+    if variance_modulus_switching > consts.safe_variance {
+        return;
+    }
+
+    let mut best_complexity = state
+        .best_solution
+        .as_ref()
+        .map_or(f64::INFINITY, |s| s.complexity);
+    let mut best_variance = state
+        .best_solution
+        .as_ref()
+        .map_or(f64::INFINITY, |s| s.noise_max);
+
+    let lower_bound_variance_br = pareto_cmux.last().unwrap().noise_br(internal_dim);
+    let lower_bound_variance_ks = pareto_keyswitch.last().unwrap().noise(input_lwe_dimension);
+    let lower_bound_variance_private_packing = pp_switch.last().unwrap().noise;
+    let lower_bound_cost_br = pareto_cmux[0].complexity_br(internal_dim);
+    let lower_bound_cost_ks = pareto_keyswitch[0].complexity(input_lwe_dimension);
+    let lower_bound_cost_pp = pp_switch[0].complexity;
+    let lower_bound_cb = CbComplexityNoise {
+        decomp: BrDecompositionParameters {
+            level: 1,
+            log2_base: 1,
+        },
+        complexity_one_cmux_hp: pareto_cb.lower_bound_cost_cb_complexity_1_cmux_hp,
+        complexity_one_ggsw_to_fft: pareto_cb.lower_bound_cost_cb_complexity_1_ggsw_to_fft,
+        variance_bias: pareto_cb.lower_pareto_cb_bias,
+        variance_ggsw_factor: pareto_cb.lower_pareto_cb_slope,
+    };
+
+    let variance = |cmux_quantity: Option<CmuxComplexityNoise>,
+                    pp_variance: Option<_>,
+                    cb_quantity: Option<&CbComplexityNoise>,
+                    ks_quantity: Option<KsComplexityNoise>| {
+        let br_variance = cmux_quantity.map_or(lower_bound_variance_br, |quantity| {
+            quantity.noise_br(internal_dim)
+        });
+        let pp_variance = pp_variance.unwrap_or(lower_bound_variance_private_packing);
+        let cb_decomp = cb_quantity.unwrap_or(&lower_bound_cb);
+        let ks_variance = ks_quantity.map_or(lower_bound_variance_ks, |quantity| {
+            quantity.noise(input_lwe_dimension)
+        });
+
+        estimate_variance(
+            br_variance,
+            pp_variance,
+            cb_decomp,
+            ks_variance,
+            variance_modulus_switching,
+            norm,
+            precisions_sum,
+            max_precision,
+        )
+    };
+
+    let lower_bound_variance = variance(None, None, None, None);
+    if lower_bound_variance > consts.safe_variance {
+        // saves 20%
+        return;
+    }
+
+    let complexity = |cmux_quantity: Option<CmuxComplexityNoise>,
+                      pp_cost: Option<_>,
+                      cb_decomp: Option<&CbComplexityNoise>,
+                      ks_quantity: Option<KsComplexityNoise>| {
+        // Pbs dans BitExtract et Circuit BS et FP-KS (partagés)
+        let br_cost = cmux_quantity.map_or(lower_bound_cost_br, |quantity| {
+            quantity.complexity_br(internal_dim)
+        });
+        let ks_cost = ks_quantity.map_or(lower_bound_cost_ks, |pareto| {
+            pareto.complexity(input_lwe_dimension)
+        });
+        let pp_cost = pp_cost.unwrap_or(lower_bound_cost_pp);
+        let cb_decomp = cb_decomp.unwrap_or(&lower_bound_cb);
+        estimate_complexity(
+            &glwe_params,
+            br_cost,
+            pp_cost,
+            cb_decomp,
+            ks_cost,
+            precisions_sum,
+            nb_blocks,
+            n_functions,
+        )
+    };
+
+    // BlindRotate dans Circuit BS
+    for &cmux_decomp in pareto_cmux {
+        let lower_bound_variance = variance(Some(cmux_decomp), None, None, None);
+
+        if lower_bound_variance > consts.safe_variance {
+            // saves 20%
+            continue;
+        }
+
+        // Circuit Boostrap
+        // private packing keyswitch, <=> FP-KS
+        for pp_switching in pp_switch {
+            let lower_bound_variance =
+                variance(Some(cmux_decomp), Some(pp_switching.noise), None, None);
+            if lower_bound_variance > safe_variance_bound {
+                continue;
+            }
+            let lower_bound_complexity =
+                complexity(Some(cmux_decomp), Some(pp_switching.complexity), None, None);
+            if lower_bound_complexity > best_complexity {
+                // saves ?? TODO
+                // next br_decomp are at least as costly
+                break;
+            }
+
+            // CircuitBootstrap: new parameters l,b
+            // for &circuit_pbs_decomposition in pareto_circuit_pbs {
+            for cb_decomp in &pareto_cb.pareto {
+                let lower_bound_variance = variance(
+                    Some(cmux_decomp),
+                    Some(pp_switching.noise),
+                    Some(cb_decomp),
+                    None,
+                );
+                if lower_bound_variance > safe_variance_bound {
+                    continue;
+                }
+                let lower_bound_complexity = complexity(
+                    Some(cmux_decomp),
+                    Some(pp_switching.complexity),
+                    Some(cb_decomp),
+                    None,
+                );
+                if lower_bound_complexity > best_complexity {
+                    // saves 50%
+                    // next circuit_pbs_decomposition_parameter are at least as costly
+                    break;
+                }
+                // Shared by all pbs (like brs)
+                for &ks_decomp in pareto_keyswitch.iter().rev() {
+                    let variance_max = variance(
+                        Some(cmux_decomp),
+                        Some(pp_switching.noise),
+                        Some(cb_decomp),
+                        Some(ks_decomp),
+                    );
+                    if variance_max > safe_variance_bound {
+                        // saves 40%
+                        break;
+                    }
+
+                    let complexity = complexity(
+                        Some(cmux_decomp),
+                        Some(pp_switching.complexity),
+                        Some(cb_decomp),
+                        Some(ks_decomp),
+                    );
+
+                    if complexity > best_complexity {
+                        continue;
+                    }
+
+                    #[allow(clippy::float_cmp)]
+                    if complexity == best_complexity && variance_max > best_variance {
+                        continue;
+                    }
+
+                    let kappa = consts.kappa;
+                    best_complexity = complexity;
+                    best_variance = variance_max;
+                    let p_error = find_p_error(kappa, safe_variance_bound, variance_max);
+                    state.best_solution = Some(Solution {
+                        input_lwe_dimension,
+                        internal_ks_output_lwe_dimension: internal_dim,
+                        ks_decomposition_level_count: ks_decomp.decomp.level,
+                        ks_decomposition_base_log: ks_decomp.decomp.log2_base,
+                        glwe_polynomial_size: glwe_params.polynomial_size(),
+                        glwe_dimension: glwe_params.glwe_dimension,
+                        br_decomposition_level_count: cmux_decomp.decomp.level,
+                        br_decomposition_base_log: cmux_decomp.decomp.log2_base,
+                        noise_max: variance_max,
+                        complexity,
+                        p_error,
+                        global_p_error: f64::NAN,
+                        cb_decomposition_level_count: cb_decomp.decomp.level,
+                        cb_decomposition_base_log: cb_decomp.decomp.log2_base,
+                        crt_decomposition: vec![],
+                        pp_decomposition_level_count: pp_switching.decomp.level,
+                        pp_decomposition_base_log: pp_switching.decomp.log2_base,
+                    });
+                }
+            }
+        }
+    }
+}
+
+fn optimize_raw(
+    log_norm: f64, // ?? norm2 of noise multisum, complexity of multisum is neglected
+    config: Config,
+    search_space: &SearchSpace,
+    n_functions: u64, // Many functions at the same time, stay at 1 for start
+    partitionning: &[u64],
+    persistent_caches: &PersistDecompCaches,
+) -> OptimizationState {
+    assert!(0.0 < config.maximum_acceptable_error_probability);
+    assert!(config.maximum_acceptable_error_probability < 1.0);
+    assert!(!partitionning.is_empty());
+
+    let ciphertext_modulus_log = config.ciphertext_modulus_log;
+
+    // Circuit BS bound
+    // 1 bit of message only here =)
+    // Bound for first bit extract in BitExtract (dominate others)
+    let max_block_precision = *partitionning.iter().max().unwrap();
+    let safe_variance_bound = safe_variance_bound_product_1padbit(
+        max_block_precision,
+        ciphertext_modulus_log,
+        config.maximum_acceptable_error_probability,
+    );
+    let kappa: f64 = sigma_scale_of_error_probability(config.maximum_acceptable_error_probability);
+
+    let mut state = OptimizationState {
+        best_solution: None,
+    };
+
+    let consts = OptimizationDecompositionsConsts {
+        config,
+        kappa,
+        sum_size: 1, // Ignored
+        noise_factor: log_norm.exp2(),
+        safe_variance: safe_variance_bound,
+    };
+
+    let mut caches = persistent_caches.caches();
+
+    for &glwe_dim in &search_space.glwe_dimensions {
+        for &glwe_log_poly_size in &search_space.glwe_log_polynomial_sizes {
+            let input_lwe_dimension = glwe_dim << glwe_log_poly_size;
+            // Manual experimental CUT
+            if input_lwe_dimension > 1 << 13 {
+                continue;
+            }
+
+            let glwe_params = GlweParameters {
+                log2_polynomial_size: glwe_log_poly_size,
+                glwe_dimension: glwe_dim,
+            };
+
+            let pareto_cmux = caches.cmux.pareto_quantities(glwe_params);
+
+            let pareto_pp_switch = caches.pp_switch.pareto_quantities(glwe_params);
+
+            let pareto_cb = caches.cb_pbs.pareto_quantities(glwe_params);
+
+            for &internal_dim in &search_space.internal_lwe_dimensions {
+                let pareto_keyswitch = caches.keyswitch.pareto_quantities(internal_dim);
+
+                update_state_with_best_decompositions(
+                    &mut state,
+                    &consts,
+                    glwe_params,
+                    internal_dim,
+                    n_functions,
+                    partitionning,
+                    pareto_cmux,
+                    pareto_keyswitch,
+                    pareto_pp_switch,
+                    pareto_cb,
+                );
+            }
+        }
+    }
+    persistent_caches.backport(caches);
+
+    state
+}
+
+pub fn optimize_one(
+    precision: u64,
+    config: Config,
+    log_norm: f64,
+    search_space: &SearchSpace,
+    caches: &PersistDecompCaches,
+) -> OptimizationState {
+    let Ok(coprimes) = crt_decomposition::default_coprimes(precision as Precision) else {
+        return OptimizationState {
+            best_solution: None,
+        }
+    };
+    let partitionning = crt_decomposition::precisions_from_coprimes(&coprimes);
+    let n_functions = 1;
+    let mut state = optimize_raw(
+        log_norm,
+        config,
+        search_space,
+        n_functions,
+        &partitionning,
+        caches,
+    );
+    state.best_solution = state.best_solution.map(|mut sol| -> Solution {
+        sol.crt_decomposition = coprimes;
+        sol
+    });
+    state
+}
+
+pub fn optimize_one_compat(
+    _sum_size: u64,
+    precision: u64,
+    config: Config,
+    noise_factor: f64,
+    search_space: &SearchSpace,
+    cache: &PersistDecompCaches,
+) -> atomic_pattern::OptimizationState {
+    let log_norm = noise_factor.log2();
+    let result = optimize_one(precision, config, log_norm, search_space, cache);
+    atomic_pattern::OptimizationState {
+        best_solution: result.best_solution.map(Solution::into),
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/parameters.rs

@@ -0,0 +1,161 @@
+pub use grouped::*;
+pub use individual::*;
+pub use range::*;
+
+mod individual {
+    use concrete_security_curves::gaussian::security::minimal_variance_glwe;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+    pub struct KsDecompositionParameters {
+        pub level: u64,
+        pub log2_base: u64,
+    }
+
+    #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+    pub struct BrDecompositionParameters {
+        pub level: u64,
+        pub log2_base: u64,
+    }
+
+    #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize, Deserialize)]
+    pub struct GlweParameters {
+        pub log2_polynomial_size: u64,
+        pub glwe_dimension: u64,
+    }
+
+    impl GlweParameters {
+        pub fn polynomial_size(self) -> u64 {
+            1 << self.log2_polynomial_size
+        }
+        pub fn sample_extract_lwe_dimension(self) -> u64 {
+            self.glwe_dimension << self.log2_polynomial_size
+        }
+
+        pub fn minimal_variance(self, ciphertext_modulus_log: u32, security_level: u64) -> f64 {
+            minimal_variance_glwe(
+                self.glwe_dimension,
+                self.polynomial_size(),
+                ciphertext_modulus_log,
+                security_level,
+            )
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct LweDimension(pub u64);
+
+    #[derive(Copy, Clone)]
+    pub struct InputParameter {
+        pub lwe_dimension: u64,
+    }
+
+    #[derive(Copy, Clone)]
+    pub struct AtomicPatternParameters {
+        pub input_lwe_dimension: LweDimension,
+        pub ks_decomposition_parameter: KsDecompositionParameters,
+        pub internal_lwe_dimension: LweDimension,
+        pub br_decomposition_parameter: BrDecompositionParameters,
+        pub output_glwe_params: GlweParameters,
+    }
+
+    impl AtomicPatternParameters {
+        pub fn pbs_parameters(self) -> PbsParameters {
+            PbsParameters {
+                internal_lwe_dimension: self.internal_lwe_dimension,
+                br_decomposition_parameter: self.br_decomposition_parameter,
+                output_glwe_params: self.output_glwe_params,
+            }
+        }
+
+        pub fn ks_parameters(self) -> KeyswitchParameters {
+            KeyswitchParameters {
+                input_lwe_dimension: self.input_lwe_dimension,
+                output_lwe_dimension: self.internal_lwe_dimension,
+                ks_decomposition_parameter: self.ks_decomposition_parameter,
+            }
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct PbsParameters {
+        pub internal_lwe_dimension: LweDimension,
+        pub br_decomposition_parameter: BrDecompositionParameters,
+        pub output_glwe_params: GlweParameters,
+    }
+
+    impl PbsParameters {
+        pub fn cmux_parameters(self) -> CmuxParameters {
+            CmuxParameters {
+                br_decomposition_parameter: self.br_decomposition_parameter,
+                output_glwe_params: self.output_glwe_params,
+            }
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct CmuxParameters {
+        pub br_decomposition_parameter: BrDecompositionParameters,
+        pub output_glwe_params: GlweParameters,
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct KeyswitchParameters {
+        pub input_lwe_dimension: LweDimension,  //n_big
+        pub output_lwe_dimension: LweDimension, //n_small
+        pub ks_decomposition_parameter: KsDecompositionParameters,
+    }
+}
+
+mod range {
+
+    use crate::global_parameters::Range;
+
+    #[derive(Clone, Copy)]
+    pub struct KsDecompositionParameterRanges {
+        pub level: Range,
+        pub log2_base: Range,
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct LweDimensionRange {
+        pub lwe_dimension: Range,
+    }
+
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    pub struct GlweParameterRanges {
+        pub log2_polynomial_size: Range,
+        pub glwe_dimension: Range,
+    }
+
+    impl From<GlweParameterRanges> for LweDimensionRange {
+        fn from(p: GlweParameterRanges) -> Self {
+            Self {
+                lwe_dimension: Range {
+                    start: (1u64 << p.log2_polynomial_size.start) * p.glwe_dimension.start,
+                    end: (1u64 << (p.log2_polynomial_size.end - 1)) * p.glwe_dimension.end,
+                },
+            }
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    pub struct BrDecompositionParameterRanges {
+        pub level: Range,
+        pub log2_base: Range,
+    }
+}
+
+mod grouped {
+    use super::{
+        BrDecompositionParameters, GlweParameters, KsDecompositionParameters, LweDimension,
+    };
+
+    #[derive(Clone)]
+    pub struct Parameters {
+        pub lwe_dimension: Vec<LweDimension>,
+        pub glwe_dimension_and_polynomial_size: Vec<GlweParameters>,
+        pub br_decomposition_parameters: Vec<BrDecompositionParameters>,
+        pub ks_decomposition_parameters: Vec<KsDecompositionParameters>,
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/utils/cache/ephemeral.rs

@@ -0,0 +1,61 @@
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::sync::Arc;
+
+use super::read_only::{Map, ReadOnlyCache};
+
+pub type KeyValueFunction<K, V> = Arc<dyn Send + Sync + Fn(K) -> V>;
+
+pub trait EphemeralCache {
+    type K;
+    type V;
+    type ROC: ReadOnlyCache<K = Self::K, V = Self::V>;
+
+    fn new(initial_content: Arc<Self::ROC>, function: KeyValueFunction<Self::K, Self::V>) -> Self;
+    fn own_new_entries(cache: Self) -> Map<Self::K, Self::V>;
+    fn get(&mut self, k: Self::K) -> &Self::V;
+}
+
+/* Cache is mono-thread obtained from a PersistentCache */
+pub struct Cache<ROC>
+where
+    ROC: ReadOnlyCache,
+{
+    initial_content: Arc<ROC>,            // shared and read-only
+    updated_content: Map<ROC::K, ROC::V>, // private mutable
+    function: KeyValueFunction<ROC::K, ROC::V>,
+}
+
+impl<ROC> EphemeralCache for Cache<ROC>
+where
+    ROC: ReadOnlyCache,
+    ROC::K: Hash + std::cmp::Eq + Copy,
+{
+    type K = ROC::K;
+    type V = ROC::V;
+    type ROC = ROC;
+
+    fn new(initial_content: Arc<Self::ROC>, function: KeyValueFunction<ROC::K, ROC::V>) -> Self {
+        Self {
+            initial_content,
+            updated_content: HashMap::default(),
+            function,
+        }
+    }
+
+    fn own_new_entries(cache: Self) -> Map<ROC::K, ROC::V> {
+        cache.updated_content
+    }
+
+    fn get(&mut self, k: ROC::K) -> &ROC::V {
+        let value = self.initial_content.get(k);
+        if let Some(value) = value {
+            return value;
+        }
+        self.updated_content
+            .entry(k)
+            .or_insert_with(|| (self.function)(k))
+    }
+}
+
+pub type CacheHashMap<K, V> = Cache<Map<K, V>>;

compilers/concrete-optimizer/concrete-optimizer/src/utils/cache/mod.rs

@@ -0,0 +1,3 @@
+pub mod ephemeral;
+pub mod persistent;
+pub(crate) mod read_only;

compilers/concrete-optimizer/concrete-optimizer/src/utils/cache/persistent.rs

@@ -0,0 +1,331 @@
+use std::borrow::BorrowMut;
+use std::io::{BufReader, BufWriter, Seek, Write};
+use std::os::unix::prelude::MetadataExt;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, RwLock, RwLockWriteGuard};
+use std::time::Instant;
+
+use file_lock::{FileLock, FileOptions};
+
+use super::ephemeral;
+use super::ephemeral::{EphemeralCache, KeyValueFunction};
+use super::read_only::{Map, ReadOnlyCache};
+
+const SHOW_DISK_ACCESS: bool = false;
+const DISABLE_CACHE: bool = false;
+
+/* PersistentCache is compatible with multi-threading */
+pub struct PersistentCache<ROC>
+where
+    ROC: ReadOnlyCache,
+{
+    // path on disk
+    path: String,
+    // version to invalidate no longer valid cache
+    version: u64,
+    // content: the HashMap is read-only, but it can be a new HashMap
+    content: RwLock<Arc<ROC>>, // the HashMap is read once, never modified and shared
+    content_changed: AtomicBool, // true if the content changed since loading from disk
+    function: KeyValueFunction<ROC::K, ROC::V>,
+}
+
+impl<ROC> Drop for PersistentCache<ROC>
+where
+    ROC: ReadOnlyCache,
+{
+    fn drop(&mut self) {
+        if DISABLE_CACHE {
+            return;
+        }
+        self.sync_to_disk();
+    }
+}
+
+impl<ROC> PersistentCache<ROC>
+where
+    ROC: ReadOnlyCache,
+{
+    pub fn new(
+        path: &str,
+        version: u64,
+        function: impl 'static + Send + Sync + Fn(ROC::K) -> ROC::V,
+    ) -> Self {
+        let cache = Self::new_no_read(path, version, function);
+        cache.read();
+        cache
+    }
+
+    pub fn new_no_read(
+        path: &str,
+        version: u64,
+        function: impl 'static + Send + Sync + Fn(ROC::K) -> ROC::V,
+    ) -> Self {
+        let path = path.into();
+        let content = RwLock::new(Arc::new(ROC::default()));
+        let content_changed = AtomicBool::new(false);
+        Self {
+            path,
+            content,
+            content_changed,
+            version,
+            function: Arc::new(function),
+        }
+    }
+
+    pub fn read(&self) {
+        let t0 = Instant::now();
+        let content = Self::read_from_disk(&self.path, self.version).unwrap_or_default();
+        if SHOW_DISK_ACCESS {
+            println!(
+                "PersistentCache: {}, reading time {} msec, {} entries",
+                self.path,
+                t0.elapsed().as_millis(),
+                content.len()
+            );
+        }
+        self.update_with(|_| content);
+        self.content_changed.store(false, Ordering::Relaxed);
+    }
+
+    pub fn cache(&self) -> ephemeral::Cache<ROC> {
+        let initial_content = self.content.read().unwrap().clone();
+        ephemeral::Cache::<ROC>::new(initial_content, self.function.clone())
+    }
+
+    pub fn backport(&self, cache: ephemeral::Cache<ROC>) {
+        if DISABLE_CACHE {
+            return;
+        }
+        let new_entries = ephemeral::Cache::<ROC>::own_new_entries(cache);
+        if new_entries.is_empty() {
+            return;
+        }
+        self.update_with(|content| ROC::extend(content, new_entries));
+    }
+
+    fn update_with<F>(&self, update: F)
+    where
+        F: FnOnce(ROC) -> ROC,
+    {
+        let (mut lock, content) = self.own_or_clone_content();
+        let len_before = content.len();
+        let content = update(content);
+        let len_after = content.len();
+        *lock = Arc::new(content);
+        drop(lock);
+        if len_before != len_after {
+            self.content_changed.store(true, Ordering::Relaxed);
+        }
+    }
+
+    fn own_or_clone_content(&self) -> (RwLockWriteGuard<Arc<ROC>>, ROC) {
+        let mut lock = self.content.write().unwrap();
+        // let's take the map ownership if possible, we need to have only one local copy
+        let arc_map = std::mem::take(&mut *lock);
+        let content = match Arc::try_unwrap(arc_map) {
+            // we own the map
+            Ok(content_map) => content_map,
+            // the map is shared elsewhere, let's clone it
+            Err(arc_map) => arc_map.as_ref().clone(),
+        };
+        (lock, content)
+    }
+
+    fn read_from_disk(path: &str, version: u64) -> Option<ROC> {
+        if DISABLE_CACHE {
+            return None;
+        }
+        if !std::path::Path::new(path).exists() {
+            // avoid creating the file if it does not exists
+            return None;
+        }
+        let options = FileOptions::new().read(true).write(true).create(true);
+        let is_blocking = true;
+        let filelock = match FileLock::lock(path, is_blocking, options) {
+            Ok(lock) => lock,
+            Err(error) => {
+                println!("PersistentCache::read_from_disk: Cannot lock cache file {path}: {error}");
+                return None;
+            }
+        };
+        Self::read_given_lock(&filelock, path, version)
+    }
+
+    pub fn sync_to_disk(&self) {
+        if !self.content_changed.load(Ordering::Relaxed) {
+            if SHOW_DISK_ACCESS {
+                println!("PersistentCache: skip sync to disk, {}", self.path);
+            }
+            return;
+        }
+        if SHOW_DISK_ACCESS {
+            println!("PersistentCache: sync to disk, {}", self.path);
+        }
+        match std::fs::create_dir_all(std::path::Path::new(&self.path).parent().unwrap()) {
+            Ok(()) => (),
+            Err(err) => {
+                let path = &self.path;
+                println!("PersistentCache::sync_to_disk: Cannot create directory {path}, {err}");
+                return;
+            }
+        };
+        let options = FileOptions::new().read(true).write(true).create(true);
+        let is_blocking = true;
+        let mut filelock = match FileLock::lock(&self.path, is_blocking, options) {
+            Ok(lock) => lock,
+            Err(_err) => {
+                println!(
+                    "PersistentCache::sync_to_disk: Cannot lock cache file {}",
+                    self.path
+                );
+                return;
+            }
+        };
+        let maybe_disk_content = Self::read_given_lock(&filelock, &self.path, self.version);
+        if let Some(disk_content) = maybe_disk_content {
+            self.update_with(|content| ROC::merge(content, disk_content));
+        }
+        self.write_given_lock(
+            &mut filelock,
+            &self.content.read().unwrap().as_ref().clone(),
+        );
+        drop(filelock.file.flush());
+        drop(filelock.file.sync_all());
+        drop(filelock);
+        self.content_changed.store(false, Ordering::Relaxed);
+    }
+
+    fn read_given_lock(filelock: &FileLock, path: &str, version: u64) -> Option<ROC> {
+        match filelock.file.metadata() {
+            Ok(metadata) => {
+                if metadata.size() == 0 {
+                    return None;
+                }
+            }
+            Err(err) => {
+                println!("PersistentCache::read_from_disk: cannot read size {path} {err}");
+                return None;
+            }
+        };
+        let mut buf = BufReader::new(&filelock.file);
+
+        let disk_version: Result<u64, _> = bincode::deserialize_from(buf.borrow_mut());
+
+        match disk_version {
+            Ok(disk_version) => {
+                if disk_version != version {
+                    println!("PersistentCache:: Invalid version {path}: cleaning");
+                    Self::clear_file(path);
+                    return None;
+                }
+            }
+            Err(error) => {
+                println!("PersistentCache::read_given_lock: Cannot read version {path}: {error}");
+                Self::clear_file(path);
+                return None;
+            }
+        }
+        match bincode::deserialize_from(buf.borrow_mut()) {
+            Ok(content) => Some(content),
+            Err(error) => {
+                println!("PersistentCache::read_given_lock: Cannot read hashmap {path}: {error}");
+                Self::clear_file(path);
+                None
+            }
+        }
+    }
+
+    fn write_given_lock(&self, filelock: &mut FileLock, content: &ROC) {
+        if SHOW_DISK_ACCESS {
+            println!(
+                "PersistentCache::write: to disk {}: {} records",
+                self.path,
+                content.len()
+            );
+        }
+        if let Err(err) = filelock.file.rewind() {
+            println!(
+                "PersistentCache::write: cannot rewind file: {}, {err}",
+                self.path
+            );
+            return;
+        }
+        if let Err(err) = filelock.file.set_len(0) {
+            println!(
+                "PersistentCache::write: cannot truncate file: {}, {err}",
+                self.path
+            );
+        }
+        let file = &mut filelock.file;
+        let mut buf = BufWriter::new(file);
+
+        bincode::serialize_into(&mut buf, &self.version).unwrap();
+        bincode::serialize_into(&mut buf, content).unwrap();
+    }
+
+    pub fn clear_file(path: &str) {
+        if !std::path::Path::new(path).exists() {
+            return;
+        }
+        let options = FileOptions::new().write(true).create(true).truncate(true);
+        let is_blocking = true;
+        let filelock = match FileLock::lock(path, is_blocking, options) {
+            Ok(lock) => lock,
+            Err(_err) => {
+                println!("PersistentCache::clear: Cannot lock cache file {path}");
+                return;
+            }
+        };
+        drop(filelock.file.sync_all());
+        drop(filelock.unlock());
+        drop(std::fs::remove_file(path));
+    }
+}
+
+pub type PersistentCacheHashMap<K, V> = PersistentCache<Map<K, V>>;
+
+pub fn default_cache_dir() -> String {
+    let mut cache_dir = std::env::temp_dir();
+    cache_dir.push("optimizer");
+    cache_dir.push("cache");
+    cache_dir.to_str().expect("Invalid tmp dir").into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::ephemeral::CacheHashMap;
+    use super::*;
+
+    #[test]
+    fn test_life_cycle() {
+        type K = (u64, u64);
+        type V = [u64; 2];
+        type PCache = PersistentCacheHashMap<K, V>;
+        let path = "/tmp/optimizer/tests/test_life_cycle";
+        let key1 = (1, 2);
+        let value1 = [3, 4];
+        let f = move |_key| value1;
+        {
+            PCache::clear_file(path);
+            let disk_cache = PCache::new(path, 0, f);
+            let mut mem_cache = disk_cache.cache();
+            let res = mem_cache.get(key1);
+            assert_eq!(res, &value1);
+            disk_cache.backport(mem_cache);
+        }
+        {
+            let cache_later = PCache::new(path, 0, f);
+            let mut mem_cache = cache_later.cache();
+            let res = mem_cache.get(key1);
+            assert_eq!(res, &value1);
+            assert!(CacheHashMap::own_new_entries(mem_cache).is_empty());
+        }
+        {
+            let cache_later = PCache::new(path, 1, f);
+            let mut mem_cache = cache_later.cache();
+            let res = mem_cache.get(key1);
+            assert_eq!(res, &value1);
+            assert!(!CacheHashMap::own_new_entries(mem_cache).is_empty());
+        }
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/utils/cache/read_only.rs

@@ -0,0 +1,52 @@
+use crate::utils::hasher_builder::FxRandomState;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::hash::Hash;
+
+pub type Map<K, V> = HashMap<K, V, FxRandomState>;
+
+#[allow(clippy::len_without_is_empty)]
+pub trait ReadOnlyCache: Clone + Serialize + DeserializeOwned + Default {
+    type K: Copy + Hash + Eq;
+    type V: Clone;
+
+    fn get(&self, k: Self::K) -> Option<&Self::V>;
+    fn merge(new_cache: Self, other_cache: Self) -> Self;
+    fn extend(roc: Self, ext: Map<Self::K, Self::V>) -> Self;
+    fn len(&self) -> usize;
+}
+
+#[allow(clippy::implicit_hasher)]
+impl<K, V> ReadOnlyCache for Map<K, V>
+where
+    K: Hash + Eq + Copy + Serialize + DeserializeOwned,
+    V: Clone + Serialize + DeserializeOwned,
+{
+    type K = K;
+    type V = V;
+
+    #[allow(clippy::only_used_in_recursion)] // clippy false positive
+    fn get(&self, k: K) -> Option<&V> {
+        self.get(&k)
+    }
+
+    fn merge(new_cache: Self, other_cache: Self) -> Self {
+        let mut new_cache = new_cache;
+        if new_cache.len() < other_cache.len() {
+            return Self::merge(other_cache, new_cache);
+        }
+        for (k, v) in other_cache {
+            let _unused = new_cache.insert(k, v);
+        }
+        new_cache
+    }
+
+    fn extend(roc: Self, ext: Map<Self::K, Self::V>) -> Self {
+        Self::merge(roc, ext)
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/utils/hasher_builder.rs

@@ -0,0 +1,33 @@
+use rand::Rng;
+use rustc_hash::FxHasher;
+use std::cell::Cell;
+use std::hash::{BuildHasher, Hasher};
+
+// Randomized hasher builder to avoid the stable hashmap trap
+// see https://morestina.net/blog/1843/the-stable-hashmap-trap
+#[derive(Copy, Clone, Debug)]
+pub struct FxRandomState(usize);
+
+impl BuildHasher for FxRandomState {
+    type Hasher = FxHasher;
+
+    fn build_hasher(&self) -> FxHasher {
+        let mut hasher = FxHasher::default();
+        hasher.write_usize(self.0);
+        hasher
+    }
+}
+
+impl Default for FxRandomState {
+    fn default() -> Self {
+        thread_local! {
+            static SEED: Cell<usize>  = Cell::new(rand::thread_rng().gen())
+        }
+        let seed = SEED.with(|seed| {
+            let n = seed.get();
+            seed.set(n.wrapping_add(1));
+            n
+        });
+        Self(seed)
+    }
+}

compilers/concrete-optimizer/concrete-optimizer/src/utils/mod.rs

@@ -0,0 +1,16 @@
+pub mod cache;
+pub mod hasher_builder;
+
+pub fn square<V>(v: V) -> V
+where
+    V: std::ops::Mul<Output = V> + Copy,
+{
+    v * v
+}
+
+pub fn square_ref<V>(v: &V) -> V
+where
+    V: std::ops::Mul<Output = V> + Copy,
+{
+    square(*v)
+}

compilers/concrete-optimizer/concrete-optimizer/src/weight.rs

@@ -0,0 +1,2 @@
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Weight(pub u64);

compilers/concrete-optimizer/v0-parameters/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "v0-parameters"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+expensive_tests = []
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+concrete-optimizer = { path ="../concrete-optimizer" }
+clap = { version = "4.0.17", features = ["derive"] }
+rayon-cond = "0.2" # to avoid rayon code coloring
+# pprof = { version = "0.4", features = ["flamegraph"] }
+rayon = "1.5.1"
+text-diff = "0.4.0"
+chrono = "0.4.19"
+
+[dev-dependencies]
+criterion = "0.4.0"
+
+[lib]
+crate-type= [
+    "lib",       # rust
+]
+bench = false
+
+[[bin]]
+name = "v0-parameters"
+bench = false
+
+[[bin]]
+name = "v0-parameters-by-level"
+bench = false
+
+[[bench]]
+name = "benchmark"
+harness = false

compilers/concrete-optimizer/v0-parameters/README.md

@@ -0,0 +1,94 @@
+# v0 Parameters
+
+The `v0-parameters` tool provides crypto-parameters that guarantee security, correctness and fast
+computation without prior knowledge of the crypto-parameter optimization.
+
+It can also be used to explore the crypto-parameter space w.r.t. the 2-norm of the dot product, the
+precision or even the failure probability.
+
+For now, we only support two kind of atomic patterns but more will be added in the near future.
+
+## Supported Atomic Patterns
+
+### Default Atomic Pattern
+
+The default atomic pattern is composed of a dot product between ciphertexts and integer weights, an
+LWE-to-LWE keyswitch and a PBS i.e.
+
+<div style="text-align: center;"> DotProduct(v) ➜ KS ➜ PBS </div>
+
+This atomic pattern allows to compute over encrypted data a dot product and a lookup-table
+evaluation for precision between 1 and 8 (with the default failure probability) and 2-norm between
+2^0 and 2^25. The 2-norm is defined as the 2-norm v of the weights of the Dot Product. It is used as
+a metric to quantify the impact of the leveled operations between two PBS on the noise  (here a
+DotProduct). Note that an atomic pattern can be described by its precision and 2-norm but only in
+the case that every inputs are independents from one another (regarding the noise).
+
+### New Atomic Pattern
+
+Another atomic pattern is available leveraging the new WoP-PBS (Without-Padding Programmable
+Bootstrapping) described in this [paper](https://eprint.iacr.org/2022/704.pdf). It is composed of a
+dot product between ciphertexts and integer weights and a WoP-PBS.
+
+<div style="text-align: center;"> DotProduct(v) ➜ WoP-PBS </div>
+
+Using this new AP, we can find parameters for precision up to 16 bits 🥳 using the optional flag `
+--wop-pbs` like that
+
+```bash
+cargo run --release -- --wop-pbs
+```
+
+## Usage
+
+The `v0-parameters` tool can take several parameters as arguments. The summary of all available
+arguments is accessible by running in the `v0-parameters/` folder
+
+```bash
+cargo run --release -- --help
+```
+
+As an alternative you can use the `optimizer` script in the root directory:
+
+```bash
+./optimizer --help
+```
+
+By default, the optimization is done on the default AP (DotProduct -> Ks -> PBS) for every available
+precision and for every 2-norm. If not specified, the correctness of the computation is guaranteed
+up to a failure probability of 2^-13.9. This can be changed using the `--p-error`
+optional argument.
+
+Try running `cargo run --release`, you will get the V0 Parameters Table that was previously used
+in `concrete-compiler`.
+
+## Advanced Usage
+
+### Playing with search spaces
+
+It is possible to choose the search space for each cryptographic parameters. For example, here we
+constrain the glwe dimension to be equal to 1:
+
+```bash
+cargo run --release -- --max-glwe-dim 1
+```
+
+### Generating reference files
+
+Some of our tests are comparing parameters found by previous version of `concrete-optimizer` against
+the parameters found by the current state of `concrete-optimizer`.
+
+To generate those references, you must be in v0-parameters directory.
+For the default AP you can do:
+
+```bash
+cargo run --release --bin v0-parameters-by-level
+```
+
+and for the new WoP-PBS AP
+
+```bash
+cargo run --release --bin v0-parameters-by-level -- --wop-pbs
+```
+
+The reference files will be written in the `ref/` folder.

compilers/concrete-optimizer/v0-parameters/benches/benchmark.rs

@@ -0,0 +1,82 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use v0_parameters::{all_results, Args, MAX_LWE_DIM, MIN_LWE_DIM, _4_SIGMA};
+
+fn v0_pbs_optimization(c: &mut Criterion) {
+    let args: Args = Args {
+        min_precision: 1,
+        max_precision: 8,
+        p_error: _4_SIGMA,
+        security_level: 128,
+        min_log_poly_size: 8,
+        max_log_poly_size: 16,
+        min_glwe_dim: 1,
+        max_glwe_dim: 1,
+        min_intern_lwe_dim: MIN_LWE_DIM,
+        max_intern_lwe_dim: MAX_LWE_DIM,
+        sum_size: 4096,
+        no_parallelize: true,
+        wop_pbs: false,
+        simulate_dag: false,
+        cache_on_disk: true,
+    };
+
+    c.bench_function("v0 PBS table generation", |b| {
+        b.iter(|| black_box(all_results(&args)))
+    });
+}
+
+fn v0_pbs_optimization_simulate_graph(c: &mut Criterion) {
+    let args: Args = Args {
+        min_precision: 1,
+        max_precision: 8,
+        p_error: _4_SIGMA,
+        security_level: 128,
+        min_log_poly_size: 8,
+        max_log_poly_size: 16,
+        min_glwe_dim: 1,
+        max_glwe_dim: 1,
+        min_intern_lwe_dim: MIN_LWE_DIM,
+        max_intern_lwe_dim: MAX_LWE_DIM,
+        sum_size: 4096,
+        no_parallelize: true,
+        wop_pbs: false,
+        simulate_dag: true,
+        cache_on_disk: true,
+    };
+
+    c.bench_function("v0 PBS simulate dag table generation", |b| {
+        b.iter(|| black_box(all_results(&args)))
+    });
+}
+
+fn v0_wop_pbs_optimization(c: &mut Criterion) {
+    let args = Args {
+        min_precision: 1,
+        max_precision: 16,
+        p_error: _4_SIGMA,
+        security_level: 128,
+        min_log_poly_size: 10,
+        max_log_poly_size: 11,
+        min_glwe_dim: 1,
+        max_glwe_dim: 2,
+        min_intern_lwe_dim: 450,
+        max_intern_lwe_dim: 600,
+        sum_size: 4096,
+        no_parallelize: true,
+        wop_pbs: true,
+        simulate_dag: false,
+        cache_on_disk: true,
+    };
+
+    c.bench_function("v0 WoP-PBS table generation", |b| {
+        b.iter(|| black_box(all_results(&args)))
+    });
+}
+
+criterion_group!(
+    benches,
+    v0_pbs_optimization,
+    v0_pbs_optimization_simulate_graph,
+    v0_wop_pbs_optimization
+);
+criterion_main!(benches);

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_112

@@ -0,0 +1,275 @@
+{ /* Security level: 112 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  530,  1, 12,  3,  3), 		 //   31 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  2,  8,  3,  3), 		 //   44 mops, 1.1e-9 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2,  8,  3,  3), 		 //   44 mops, 4.2e-9 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  2,  8,  3,  3), 		 //   44 mops, 2.1e-7 errors
+    /*  4 */ V0Parameter( 1, 10,  516,  2,  8,  4,  3), 		 //   45 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  512,  1, 23,  3,  3), 		 //   51 mops, 1.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  1, 23,  3,  3), 		 //   51 mops, 1.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  512,  1, 23,  3,  3), 		 //   51 mops, 1.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  512,  1, 23,  3,  3), 		 //   51 mops, 1.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  512,  1, 23,  3,  3), 		 //   51 mops, 4.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  521,  1, 23,  4,  3), 		 //   54 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 1.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 1.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 1.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 1.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 1.6e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  512,  2, 16,  3,  3), 		 //   72 mops, 3.5e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  529,  2, 16,  3,  3), 		 //   74 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  3,  3), 		 //   93 mops, 1.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  512,  3, 12,  3,  3), 		 //   93 mops, 1.8e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  3, 12,  3,  3), 		 //   93 mops, 5.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 //   97 mops, 2.4e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  4,  9,  3,  3), 		 //  114 mops, 4.6e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  521,  4,  9,  4,  3), 		 //  118 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  517,  5,  8,  3,  3), 		 //  136 mops, 5.5e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  6,  7,  4,  3), 		 //  158 mops, 4.2e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  513,  7,  6,  4,  3), 		 //  179 mops, 5.3e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  516,  8,  5,  5,  2), 		 //  204 mops, 6.0e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  512, 11,  4,  5,  2), 		 //  265 mops, 1.2e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  512, 15,  3,  6,  2), 		 //  351 mops, 5.8e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  512, 44,  1,  5,  2), 		 //  958 mops, 2.8e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  520,  2,  8,  4,  3), 		 //   45 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  521,  2,  8,  4,  3), 		 //   45 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2,  8,  5,  2), 		 //   46 mops, 9.1e-6 errors
+    /*  3 */ V0Parameter( 1, 10,  558,  2,  8,  4,  3), 		 //   48 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  537,  1, 23,  4,  3), 		 //   55 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  537,  1, 23,  4,  3), 		 //   55 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  537,  1, 23,  4,  3), 		 //   55 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  538,  1, 23,  4,  3), 		 //   55 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  541,  1, 23,  4,  3), 		 //   56 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  559,  1, 23,  4,  3), 		 //   57 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  521,  2, 16,  5,  2), 		 //   77 mops, 5.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  521,  2, 16,  5,  2), 		 //   77 mops, 5.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  521,  2, 16,  5,  2), 		 //   77 mops, 5.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  2, 16,  5,  2), 		 //   77 mops, 5.5e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 //   77 mops, 5.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  540,  2, 16,  4,  3), 		 //   78 mops, 5.5e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  552,  2, 16,  4,  3), 		 //   79 mops, 5.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  521,  3, 12,  5,  2), 		 //   99 mops, 5.6e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522,  3, 12,  5,  2), 		 //   99 mops, 5.8e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  527,  3, 12,  5,  2), 		 //  100 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  564,  3, 12,  4,  3), 		 //  104 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  526,  4,  9,  5,  2), 		 //  121 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  536,  4,  9,  6,  2), 		 //  125 mops, 5.9e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  523,  5,  8,  6,  2), 		 //  144 mops, 5.1e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  524,  6,  7,  6,  2), 		 //  166 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  526,  7,  6,  6,  2), 		 //  188 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  555,  8,  5,  6,  2), 		 //  221 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  536, 11,  4,  6,  2), 		 //  279 mops, 5.9e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  555, 15,  3,  6,  2), 		 //  380 mops, 6.1e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  531, 44,  1, 12,  1), 		 // 1008 mops, 6.0e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  558,  2,  8,  4,  3), 		 //   48 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  563,  2,  8,  4,  3), 		 //   49 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  593,  2,  8,  7,  2), 		 //   54 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  601,  1, 23,  3,  4), 		 //   59 mops, 5.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  601,  1, 23,  3,  4), 		 //   59 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  601,  1, 23,  3,  4), 		 //   59 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  602,  1, 23,  3,  4), 		 //   59 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  579,  1, 23,  4,  3), 		 //   59 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  609,  1, 23,  4,  3), 		 //   62 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  575,  2, 16,  4,  3), 		 //   82 mops, 4.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  575,  2, 16,  4,  3), 		 //   82 mops, 4.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  575,  2, 16,  4,  3), 		 //   82 mops, 4.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  575,  2, 16,  4,  3), 		 //   82 mops, 5.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  575,  2, 16,  4,  3), 		 //   82 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  578,  2, 16,  4,  3), 		 //   83 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  595,  2, 16,  4,  3), 		 //   85 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  575,  3, 12,  4,  3), 		 //  106 mops, 5.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576,  3, 12,  4,  3), 		 //  106 mops, 5.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  580,  3, 12,  4,  3), 		 //  107 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  596,  3, 12,  6,  2), 		 //  114 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  557,  4,  9,  6,  2), 		 //  130 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  584,  4,  9,  6,  2), 		 //  136 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  562,  5,  8,  6,  2), 		 //  154 mops, 5.9e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  564,  6,  7,  6,  2), 		 //  178 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  567,  7,  6,  6,  2), 		 //  202 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  574,  9,  5,  6,  2), 		 //  251 mops, 5.7e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  584, 11,  4,  6,  2), 		 //  304 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  564, 22,  2,  6,  2), 		 //  548 mops, 5.9e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  578, 44,  1, 13,  1), 		 // 1099 mops, 6.2e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  624,  2,  8,  4,  3), 		 //   53 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  665,  1, 23,  3,  4), 		 //   64 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  665,  1, 23,  3,  4), 		 //   64 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  665,  1, 23,  3,  4), 		 //   64 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  666,  1, 23,  3,  4), 		 //   64 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  671,  1, 23,  3,  4), 		 //   65 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  687,  1, 23,  3,  5), 		 //   66 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  637,  2, 16,  4,  3), 		 //   90 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  637,  2, 16,  4,  3), 		 //   90 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  637,  2, 16,  4,  3), 		 //   90 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  637,  2, 16,  4,  3), 		 //   90 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  638,  2, 16,  4,  3), 		 //   90 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  641,  2, 16,  4,  3), 		 //   91 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  628,  2, 16,  5,  3), 		 //   92 mops, 5.5e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  655,  2, 16,  8,  2), 		 //  103 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  622,  3, 12,  5,  3), 		 //  116 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  624,  3, 12,  5,  3), 		 //  117 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  631,  3, 12,  5,  3), 		 //  118 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  600,  4,  9,  7,  2), 		 //  142 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  606,  4,  9,  7,  2), 		 //  143 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  602,  5,  8,  7,  2), 		 //  167 mops, 5.5e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  616,  5,  8,  7,  2), 		 //  171 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  621,  6,  7,  7,  2), 		 //  197 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  630,  7,  6,  7,  2), 		 //  226 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  606, 11,  4,  7,  2), 		 //  317 mops, 6.0e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  617, 14,  3,  7,  2), 		 //  399 mops, 5.9e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  621, 22,  2,  7,  2), 		 //  605 mops, 5.9e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  657,  1, 23,  5,  3), 		 //   87 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  657,  1, 23,  5,  3), 		 //   87 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  657,  1, 23,  5,  3), 		 //   87 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  658,  1, 23,  5,  3), 		 //   87 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  659,  1, 23,  5,  3), 		 //   87 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  668,  1, 23,  5,  3), 		 //   88 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  657,  2, 15,  5,  3), 		 //  123 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  657,  2, 15,  5,  3), 		 //  123 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  657,  2, 15,  5,  3), 		 //  123 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  657,  2, 15,  5,  3), 		 //  123 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  658,  2, 15,  5,  3), 		 //  123 mops, 5.4e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  659,  2, 15,  5,  3), 		 //  123 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  665,  2, 15,  5,  3), 		 //  124 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  657,  3, 12,  5,  3), 		 //  159 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  658,  3, 12,  5,  3), 		 //  159 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  660,  3, 12,  5,  3), 		 //  160 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  671,  3, 12,  5,  3), 		 //  162 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  638,  4,  9,  7,  2), 		 //  194 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  647,  4,  9,  7,  2), 		 //  197 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  641,  5,  8,  7,  2), 		 //  230 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  665,  5,  8,  8,  2), 		 //  241 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  683,  6,  7,  8,  2), 		 //  285 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  650,  8,  5,  8,  2), 		 //  343 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  649, 11,  4,  7,  2), 		 //  446 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  663, 14,  3,  8,  2), 		 //  567 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  678, 22,  2,  8,  2), 		 //  876 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  739,  1, 23,  4,  4), 		 //  200 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  739,  1, 23,  4,  4), 		 //  200 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  741,  1, 23,  4,  4), 		 //  201 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  749,  1, 23,  4,  4), 		 //  203 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  718,  2, 15,  5,  3), 		 //  285 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  718,  2, 15,  5,  3), 		 //  285 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  718,  2, 15,  5,  3), 		 //  285 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  718,  2, 15,  5,  3), 		 //  285 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  718,  2, 15,  5,  3), 		 //  285 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  720,  2, 15,  5,  3), 		 //  286 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  727,  2, 15,  5,  3), 		 //  288 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  734,  2, 15,  9,  2), 		 //  314 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  719,  3, 12,  5,  3), 		 //  369 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  723,  3, 12,  5,  3), 		 //  371 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  710,  3, 12,  8,  2), 		 //  382 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  691,  4,  9,  8,  2), 		 //  453 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  698,  4,  9,  8,  2), 		 //  457 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  696,  5,  8,  8,  2), 		 //  538 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  697,  6,  7,  8,  2), 		 //  620 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  699,  7,  6,  8,  2), 		 //  704 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  706,  8,  5,  8,  2), 		 //  793 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  707, 11,  4,  8,  2), 		 // 1043 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  724, 14,  3,  9,  2), 		 // 1328 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  700, 43,  1, 17,  1), 		 // 3707 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  768,  1, 23,  6,  3), 		 //  464 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  775,  1, 23,  6,  3), 		 //  468 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  766,  2, 15,  6,  3), 		 //  654 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  766,  2, 15,  6,  3), 		 //  654 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  766,  2, 15,  6,  3), 		 //  654 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  766,  2, 15,  6,  3), 		 //  654 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  766,  2, 15,  6,  3), 		 //  654 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  767,  2, 15,  6,  3), 		 //  655 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  771,  2, 15,  6,  3), 		 //  658 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  808,  2, 15,  6,  3), 		 //  688 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  767,  3, 11,  6,  3), 		 //  847 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  769,  3, 11,  6,  3), 		 //  849 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  781,  3, 11,  6,  3), 		 //  861 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  768,  4,  9,  6,  3), 		 // 1040 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  775,  4,  9,  6,  3), 		 // 1049 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  752,  5,  8,  9,  2), 		 // 1242 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  754,  6,  7,  9,  2), 		 // 1434 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  756,  7,  6,  9,  2), 		 // 1626 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  762,  8,  5,  9,  2), 		 // 1830 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  799, 10,  4, 10,  2), 		 // 2329 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  803, 14,  3, 20,  1), 		 // 3269 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  761, 43,  1, 19,  1), 		 // 8605 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  829,  2, 15,  6,  3), 		 // 1489 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  829,  2, 15,  6,  3), 		 // 1489 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  829,  2, 15,  6,  3), 		 // 1489 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  829,  2, 15,  6,  3), 		 // 1489 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  829,  2, 15,  6,  3), 		 // 1489 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  831,  2, 15,  6,  3), 		 // 1492 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  853,  2, 15,  5,  4), 		 // 1503 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  865,  2, 15,  7,  3), 		 // 1578 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  830,  3, 11,  6,  3), 		 // 1931 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  833,  3, 11,  6,  3), 		 // 1938 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  833,  3, 11,  7,  3), 		 // 1964 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  832,  4,  9,  6,  3), 		 // 2378 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  832,  4,  9,  7,  3), 		 // 2404 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  809,  5,  8, 10,  2), 		 // 2845 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  813,  6,  7, 10,  2), 		 // 3291 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  816,  7,  6, 10,  2), 		 // 3736 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  824,  8,  5, 10,  2), 		 // 4210 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  853, 11,  4, 11,  2), 		 // 5742 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  812, 21,  2, 10,  2), 		 // 9757 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 14,  840, 43,  1, 21,  1), 		 // 20198 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_128

@@ -0,0 +1,275 @@
+{ /* Security level: 128 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  556,  2,  8,  3,  3), 		 //   47 mops, 5.3e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  558,  2,  8,  3,  3), 		 //   47 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  543,  2,  8,  5,  2), 		 //   48 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  582,  1, 23,  3,  3), 		 //   57 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  1, 23,  3,  3), 		 //   57 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  603,  1, 23,  4,  3), 		 //   61 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  581,  2, 16,  3,  3), 		 //   81 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  585,  2, 16,  3,  3), 		 //   81 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  568,  2, 16,  5,  2), 		 //   84 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  550,  3, 12,  5,  2), 		 //  104 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551,  3, 12,  5,  2), 		 //  104 mops, 5.5e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  555,  3, 12,  5,  2), 		 //  105 mops, 5.6e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  586,  3, 12,  5,  2), 		 //  110 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  554,  4,  9,  5,  2), 		 //  127 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  578,  4,  9,  5,  2), 		 //  132 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  559,  5,  8,  5,  2), 		 //  151 mops, 5.8e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  561,  6,  7,  5,  2), 		 //  175 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  564,  7,  6,  5,  2), 		 //  199 mops, 5.8e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  604,  8,  5,  6,  2), 		 //  239 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  578, 11,  4,  5,  2), 		 //  298 mops, 6.2e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  604, 15,  3,  6,  2), 		 //  413 mops, 6.2e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  572, 44,  1, 11,  1), 		 // 1083 mops, 5.8e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  575,  2,  8,  5,  2), 		 //   51 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  591,  2,  8,  5,  2), 		 //   52 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  617,  1, 23,  4,  3), 		 //   62 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  621,  1, 23,  4,  3), 		 //   63 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  648,  1, 23,  4,  3), 		 //   65 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  598,  2, 16,  5,  2), 		 //   88 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  619,  2, 16,  4,  3), 		 //   88 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  636,  2, 16,  4,  3), 		 //   90 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  598,  3, 12,  5,  2), 		 //  112 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  599,  3, 12,  5,  2), 		 //  112 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  606,  3, 12,  5,  2), 		 //  113 mops, 5.7e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  630,  3, 12,  6,  2), 		 //  120 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  605,  4,  9,  5,  2), 		 //  138 mops, 5.6e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  621,  4,  9,  6,  2), 		 //  144 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  601,  5,  8,  6,  2), 		 //  164 mops, 5.6e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  603,  6,  7,  6,  2), 		 //  189 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  606,  7,  6,  6,  2), 		 //  215 mops, 5.8e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  612,  9,  5,  6,  2), 		 //  268 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  621, 11,  4,  6,  2), 		 //  322 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  629, 21,  2,  6,  2), 		 //  584 mops, 6.1e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  620, 44,  1, 12,  1), 		 // 1176 mops, 6.1e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  658,  2,  8,  4,  3), 		 //   56 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  689,  1, 23,  3,  4), 		 //   66 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  695,  1, 23,  3,  4), 		 //   67 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  736,  1, 23,  4,  3), 		 //   73 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  659,  2, 16,  4,  3), 		 //   93 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  663,  2, 16,  4,  3), 		 //   94 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  688,  2, 16,  4,  3), 		 //   97 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  659,  3, 12,  4,  3), 		 //  120 mops, 5.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  660,  3, 12,  4,  3), 		 //  120 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  666,  3, 12,  4,  3), 		 //  121 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  702,  3, 12,  7,  2), 		 //  136 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  640,  4,  9,  6,  2), 		 //  148 mops, 5.4e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  677,  4,  9,  7,  2), 		 //  159 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  646,  5,  8,  6,  2), 		 //  176 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  650,  6,  7,  6,  2), 		 //  204 mops, 5.7e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  654,  7,  6,  6,  2), 		 //  232 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  665,  9,  5,  6,  2), 		 //  290 mops, 6.1e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  677, 11,  4,  7,  2), 		 //  353 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  649, 22,  2,  6,  2), 		 //  629 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  672, 45,  1, 13,  1), 		 // 1304 mops, 6.1e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  771,  1, 23,  3,  4), 		 //   73 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  745,  1, 23,  4,  3), 		 //   74 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  792,  1, 23,  3,  5), 		 //   75 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  716,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  723,  2, 16,  5,  3), 		 //  104 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  714,  3, 12,  5,  3), 		 //  132 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  714,  3, 12,  5,  3), 		 //  132 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  717,  3, 12,  5,  3), 		 //  133 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  728,  3, 12,  5,  3), 		 //  135 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  690,  4,  9,  7,  2), 		 //  162 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  699,  4,  9,  7,  2), 		 //  164 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  692,  5,  8,  7,  2), 		 //  191 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  718,  5,  8,  7,  2), 		 //  198 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  735,  6,  7,  7,  2), 		 //  232 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  705,  8,  5,  7,  2), 		 //  281 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  699, 11,  4,  7,  2), 		 //  365 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  720, 14,  3,  7,  2), 		 //  464 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  733, 22,  2,  7,  2), 		 //  713 mops, 6.2e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  755,  1, 23,  5,  3), 		 //   99 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  757,  1, 23,  5,  3), 		 //   99 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  771,  1, 23,  5,  3), 		 //  101 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  756,  2, 15,  5,  3), 		 //  140 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  766,  2, 15,  5,  3), 		 //  142 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  754,  3, 12,  5,  3), 		 //  181 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  755,  3, 12,  5,  3), 		 //  182 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  758,  3, 12,  5,  3), 		 //  182 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  779,  3, 12,  5,  3), 		 //  187 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  734,  4,  9,  7,  2), 		 //  223 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  749,  4,  9,  7,  2), 		 //  227 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  738,  5,  8,  7,  2), 		 //  264 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  740,  6,  7,  7,  2), 		 //  305 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  742,  7,  6,  7,  2), 		 //  347 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  754,  8,  5,  8,  2), 		 //  396 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  747, 11,  4,  8,  2), 		 //  515 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  760, 15,  3,  8,  2), 		 //  690 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  752, 43,  1, 16,  1), 		 // 1858 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  847,  1, 23,  4,  4), 		 //  227 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  848,  1, 23,  4,  4), 		 //  228 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  850,  1, 23,  4,  4), 		 //  228 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  864,  1, 23,  4,  4), 		 //  232 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  825,  2, 15,  5,  3), 		 //  325 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  827,  2, 15,  5,  3), 		 //  326 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  858,  2, 15,  4,  4), 		 //  331 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  825,  3, 12,  5,  3), 		 //  422 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  826,  3, 12,  5,  3), 		 //  422 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  796,  3, 12,  8,  2), 		 //  426 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  858,  3, 12,  6,  3), 		 //  445 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  793,  4,  9,  8,  2), 		 //  517 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  805,  4,  9,  8,  2), 		 //  525 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  801,  5,  8,  8,  2), 		 //  616 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  803,  6,  7,  8,  2), 		 //  712 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  806,  7,  6,  8,  2), 		 //  809 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  821,  8,  5,  8,  2), 		 //  920 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  820, 11,  4,  9,  2), 		 // 1214 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  809, 21,  2,  8,  2), 		 // 2139 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  821, 43,  1, 17,  1), 		 // 4345 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  880,  1, 23,  6,  3), 		 //  527 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  893,  1, 23,  6,  3), 		 //  534 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  878,  2, 15,  6,  3), 		 //  745 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  879,  2, 15,  6,  3), 		 //  746 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  886,  2, 15,  6,  3), 		 //  752 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  878,  3, 11,  6,  3), 		 //  965 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  878,  3, 11,  6,  3), 		 //  965 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  882,  3, 11,  6,  3), 		 //  969 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  906,  3, 11,  6,  3), 		 //  994 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  880,  4,  9,  6,  3), 		 // 1187 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  893,  4,  9,  6,  3), 		 // 1204 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  866,  5,  8,  9,  2), 		 // 1425 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  870,  6,  7,  9,  2), 		 // 1649 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  875,  7,  6,  9,  2), 		 // 1877 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  891,  8,  5,  9,  2), 		 // 2134 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  906, 11,  4, 20,  1), 		 // 3005 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  871, 21,  2,  9,  2), 		 // 4917 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  953,  2, 15,  6,  3), 		 // 1702 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  972,  2, 15,  5,  4), 		 // 1704 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  980,  2, 15,  5,  4), 		 // 1717 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  952,  3, 11,  6,  3), 		 // 2206 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  954,  3, 11,  6,  3), 		 // 2210 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  944,  3, 11,  7,  3), 		 // 2217 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  962,  3, 11,  7,  3), 		 // 2258 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  943,  4,  9,  7,  3), 		 // 2716 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  959,  4,  9,  7,  3), 		 // 2761 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  934,  5,  8, 10,  2), 		 // 3275 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  941,  6,  7, 10,  2), 		 // 3799 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  953,  7,  6, 10,  2), 		 // 4352 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  924, 10,  4, 10,  2), 		 // 5695 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  926, 14,  3, 10,  2), 		 // 7675 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  939, 21,  2, 10,  2), 		 // 11273 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_144

@@ -0,0 +1,275 @@
+{ /* Security level: 144 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  653,  1, 22,  3,  3), 		 //   63 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  655,  1, 22,  3,  3), 		 //   63 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  661,  1, 22,  3,  3), 		 //   64 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  678,  1, 22,  4,  3), 		 //   68 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  653,  2, 15,  3,  3), 		 //   90 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  653,  2, 15,  3,  3), 		 //   90 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  653,  2, 15,  3,  3), 		 //   90 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  653,  2, 15,  3,  3), 		 //   90 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  654,  2, 15,  3,  3), 		 //   90 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  658,  2, 15,  3,  3), 		 //   90 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  638,  2, 15,  5,  2), 		 //   93 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  620,  3, 11,  5,  2), 		 //  116 mops, 5.1e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  621,  3, 11,  5,  2), 		 //  116 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  627,  3, 11,  5,  2), 		 //  117 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  621,  4,  9,  5,  2), 		 //  142 mops, 5.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  626,  4,  9,  5,  2), 		 //  143 mops, 5.5e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  676,  4,  9,  5,  2), 		 //  153 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  678,  5,  8,  6,  2), 		 //  184 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  630,  7,  6,  5,  2), 		 //  221 mops, 5.7e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  633,  8,  5,  5,  2), 		 //  248 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  643, 10,  4,  5,  2), 		 //  305 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  652, 14,  3,  5,  2), 		 //  416 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  662, 14,  3,  6,  2), 		 //  606 mops, 6.2e-5 errors
+    /* 29 */ V0Parameter( 3, 10,  675, 22,  2,  6,  2), 		 //  934 mops, 6.2e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  692,  1, 22,  4,  3), 		 //   69 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  692,  1, 22,  4,  3), 		 //   69 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  692,  1, 22,  4,  3), 		 //   69 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  692,  1, 22,  4,  3), 		 //   69 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  693,  1, 22,  4,  3), 		 //   69 mops, 4.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  693,  1, 22,  4,  3), 		 //   69 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  694,  1, 22,  4,  3), 		 //   69 mops, 5.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  698,  1, 22,  4,  3), 		 //   70 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  728,  1, 22,  4,  3), 		 //   72 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  692,  2, 15,  4,  3), 		 //   97 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  692,  2, 15,  4,  3), 		 //   97 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  672,  2, 15,  5,  2), 		 //   97 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  672,  2, 15,  5,  2), 		 //   97 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  693,  2, 15,  4,  3), 		 //   98 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  696,  2, 15,  4,  3), 		 //   98 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  713,  2, 15,  4,  3), 		 //  100 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  673,  3, 11,  5,  2), 		 //  125 mops, 5.4e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  675,  3, 11,  5,  2), 		 //  126 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  701,  3, 11,  4,  3), 		 //  127 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  674,  4,  9,  5,  2), 		 //  153 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  683,  4,  9,  5,  2), 		 //  155 mops, 5.9e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  729,  4,  9,  6,  2), 		 //  168 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  675,  6,  7,  6,  2), 		 //  211 mops, 5.2e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  676,  7,  6,  6,  2), 		 //  239 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  680,  8,  5,  6,  2), 		 //  269 mops, 5.7e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  691, 10,  4,  6,  2), 		 //  329 mops, 5.8e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  700, 14,  3,  6,  2), 		 //  448 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  712, 14,  3,  6,  2), 		 //  651 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  734, 22,  2,  6,  2), 		 // 1015 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  773,  1, 22,  3,  4), 		 //   73 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  773,  1, 22,  3,  4), 		 //   73 mops, 5.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  773,  1, 22,  3,  4), 		 //   73 mops, 5.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  773,  1, 22,  3,  4), 		 //   73 mops, 5.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  773,  1, 22,  3,  4), 		 //   73 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  774,  1, 22,  3,  4), 		 //   73 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  780,  1, 22,  3,  4), 		 //   74 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  796,  1, 22,  5,  3), 		 //   81 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  740,  2, 15,  4,  3), 		 //  104 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  740,  2, 15,  4,  3), 		 //  104 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  740,  2, 15,  4,  3), 		 //  104 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  740,  2, 15,  4,  3), 		 //  104 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  741,  2, 15,  4,  3), 		 //  104 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  745,  2, 15,  4,  3), 		 //  104 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  771,  2, 15,  4,  3), 		 //  108 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  740,  3, 11,  4,  3), 		 //  134 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  742,  3, 11,  4,  3), 		 //  134 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  752,  3, 11,  4,  3), 		 //  136 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  715,  4,  9,  6,  2), 		 //  165 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  722,  4,  9,  6,  2), 		 //  166 mops, 5.6e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  722,  5,  8,  6,  2), 		 //  196 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  725,  6,  7,  6,  2), 		 //  226 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  728,  7,  6,  6,  2), 		 //  257 mops, 5.7e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  733,  8,  5,  6,  2), 		 //  289 mops, 6.0e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  754, 10,  4,  6,  2), 		 //  359 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  765, 14,  3,  7,  2), 		 //  492 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  776, 14,  3,  7,  2), 		 //  713 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  745, 43,  1, 13,  1), 		 // 1977 mops, 6.2e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  875,  1, 22,  3,  5), 		 //   82 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  875,  1, 22,  3,  5), 		 //   82 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  875,  1, 22,  3,  5), 		 //   82 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  876,  1, 22,  3,  5), 		 //   82 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  879,  1, 22,  3,  5), 		 //   82 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  821,  1, 22,  5,  3), 		 //   84 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  805,  2, 15,  5,  3), 		 //  115 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  805,  2, 15,  5,  3), 		 //  115 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  805,  2, 15,  5,  3), 		 //  115 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  805,  2, 15,  5,  3), 		 //  115 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  805,  2, 15,  5,  3), 		 //  115 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  807,  2, 15,  5,  3), 		 //  115 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  815,  2, 15,  5,  3), 		 //  117 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  805,  3, 11,  5,  3), 		 //  148 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  806,  3, 11,  5,  3), 		 //  148 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  810,  3, 11,  5,  3), 		 //  149 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  837,  3, 11,  5,  3), 		 //  154 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  779,  4,  9,  7,  2), 		 //  182 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  797,  4,  9,  7,  2), 		 //  186 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  799,  5,  8,  7,  2), 		 //  219 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  809,  6,  7,  7,  2), 		 //  255 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  827,  7,  6,  7,  2), 		 //  294 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  788, 10,  4,  7,  2), 		 //  378 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  791, 14,  3,  7,  2), 		 //  509 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  805, 14,  3,  7,  2), 		 //  740 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  810, 22,  2,  7,  2), 		 // 1124 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  850,  1, 22,  5,  3), 		 //  110 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  850,  1, 22,  5,  3), 		 //  110 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  851,  1, 22,  5,  3), 		 //  111 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  854,  1, 22,  5,  3), 		 //  111 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  873,  1, 22,  5,  3), 		 //  113 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  850,  2, 15,  5,  3), 		 //  157 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  850,  2, 15,  5,  3), 		 //  157 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  850,  2, 15,  5,  3), 		 //  157 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  850,  2, 15,  5,  3), 		 //  157 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  850,  2, 15,  5,  3), 		 //  157 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  853,  2, 15,  5,  3), 		 //  157 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  867,  2, 15,  5,  3), 		 //  160 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  850,  3, 11,  5,  3), 		 //  203 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  851,  3, 11,  5,  3), 		 //  204 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  857,  3, 11,  5,  3), 		 //  205 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  884,  3, 11,  8,  2), 		 //  222 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  831,  4,  9,  7,  2), 		 //  251 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  864,  4,  9,  8,  2), 		 //  264 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  884,  5,  8,  8,  2), 		 //  318 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  836,  7,  6,  7,  2), 		 //  390 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  840,  8,  5,  7,  2), 		 //  437 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  842, 10,  4,  8,  2), 		 //  534 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  850, 14,  3,  8,  2), 		 //  725 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 2, 11,  900, 15,  3,  8,  2), 		 // 1322 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 11,  871, 43,  1, 16,  1), 		 // 3478 mops, 6.3e-5 errors
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  954,  1, 23,  4,  4), 		 //  254 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  955,  1, 23,  4,  4), 		 //  254 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  959,  1, 23,  4,  4), 		 //  255 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  989,  1, 23,  4,  4), 		 //  263 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  932,  2, 15,  5,  3), 		 //  365 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  932,  2, 15,  5,  3), 		 //  365 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  932,  2, 15,  5,  3), 		 //  365 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  932,  2, 15,  5,  3), 		 //  365 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  933,  2, 15,  5,  3), 		 //  365 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  937,  2, 15,  5,  3), 		 //  367 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  973,  2, 15,  4,  4), 		 //  373 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  933,  3, 12,  5,  3), 		 //  475 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  935,  3, 12,  5,  3), 		 //  476 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  928,  3, 12,  6,  3), 		 //  480 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  892,  4,  9,  8,  2), 		 //  580 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  895,  4,  9,  8,  2), 		 //  582 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  915,  4,  9,  8,  2), 		 //  595 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  907,  5,  8,  8,  2), 		 //  696 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  912,  6,  7,  8,  2), 		 //  806 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  919,  7,  6,  8,  2), 		 //  920 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  955,  8,  5,  9,  2), 		 // 1075 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  950, 11,  4, 18,  1), 		 // 1470 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  919, 21,  2,  9,  2), 		 // 2435 mops, 6.2e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  993,  1, 23,  6,  3), 		 //  590 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 13, 1018,  1, 23,  6,  3), 		 //  604 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  988,  2, 15,  6,  3), 		 //  834 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  988,  2, 15,  6,  3), 		 //  834 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  988,  2, 15,  6,  3), 		 //  834 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  988,  2, 15,  6,  3), 		 //  834 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  989,  2, 15,  6,  3), 		 //  835 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  991,  2, 15,  6,  3), 		 //  837 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13, 1002,  2, 15,  6,  3), 		 //  846 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  989,  3, 11,  6,  3), 		 // 1082 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  990,  3, 11,  6,  3), 		 // 1084 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  996,  3, 11,  6,  3), 		 // 1090 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 13, 1017,  3, 11, 10,  2), 		 // 1176 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  993,  4,  9,  6,  3), 		 // 1335 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 13, 1018,  4,  9,  6,  3), 		 // 1368 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  984,  5,  8,  9,  2), 		 // 1615 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  994,  6,  7,  9,  2), 		 // 1880 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 13, 1006,  7,  6, 10,  2), 		 // 2169 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  975, 10,  4,  9,  2), 		 // 2820 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  976, 14,  3,  9,  2), 		 // 3798 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  996, 21,  2, 10,  2), 		 // 5634 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14, 1017,  2, 15, 19,  1), 		 // 2226 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 14, 1017,  2, 15, 19,  1), 		 // 2226 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 14, 1017,  2, 15, 19,  1), 		 // 2226 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 1, 14, 1018,  2, 15, 19,  1), 		 // 2228 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 14, 1018,  2, 15, 19,  1), 		 // 2228 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 14, 1020,  2, 15, 19,  1), 		 // 2232 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 14, 1017,  3, 11, 19,  1), 		 // 2766 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 14, 1018,  3, 11, 19,  1), 		 // 2768 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 1, 14, 1019,  3, 11, 19,  1), 		 // 2771 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 14, 1024,  3, 11, 19,  1), 		 // 2784 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 14, 1019,  4,  9, 19,  1), 		 // 3312 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 14, 1023,  4,  9, 19,  1), 		 // 3325 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 14, 1024,  5,  8, 19,  1), 		 // 3872 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 14, 1023,  6,  7, 20,  1), 		 // 4444 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 14, 1024,  7,  6, 20,  1), 		 // 4992 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 14, 1021, 10,  4, 19,  1), 		 // 6573 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 14, 1022, 14,  3, 19,  1), 		 // 8751 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 14, 1022, 21,  2, 20,  1), 		 // 12584 mops, 6.3e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_160

@@ -0,0 +1,275 @@
+{ /* Security level: 160 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  725,  1, 22,  3,  3), 		 //   69 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  725,  1, 22,  3,  3), 		 //   69 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  726,  1, 22,  3,  3), 		 //   69 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  726,  1, 22,  3,  3), 		 //   69 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  730,  1, 22,  3,  3), 		 //   70 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  748,  1, 22,  3,  3), 		 //   71 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  725,  2, 15,  3,  3), 		 //   99 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  725,  2, 15,  3,  3), 		 //   99 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  726,  2, 15,  3,  3), 		 //   99 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  726,  2, 15,  3,  3), 		 //   99 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  727,  2, 15,  3,  3), 		 //   99 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  734,  2, 15,  3,  3), 		 //  100 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  727,  2, 15,  5,  2), 		 //  105 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  689,  3, 11,  5,  2), 		 //  128 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  691,  3, 11,  5,  2), 		 //  128 mops, 5.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  698,  3, 11,  5,  2), 		 //  130 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  714,  2, 15,  5,  2), 		 //  147 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  704,  3, 12,  5,  2), 		 //  186 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  705,  3, 12,  5,  2), 		 //  186 mops, 5.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  708,  3, 12,  5,  2), 		 //  187 mops, 5.4e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  725,  3, 12,  5,  2), 		 //  191 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  707,  4,  9,  5,  2), 		 //  228 mops, 5.3e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  718,  4,  9,  5,  2), 		 //  232 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  711,  5,  8,  5,  2), 		 //  271 mops, 5.4e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  747,  5,  8,  6,  2), 		 //  289 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  775,  6,  7,  6,  2), 		 //  345 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  728,  8,  5,  5,  2), 		 //  405 mops, 5.8e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  722, 11,  4,  5,  2), 		 //  529 mops, 6.0e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  742, 14,  3,  6,  2), 		 //  678 mops, 6.3e-5 errors
+    /* 29 */ V0Parameter( 3, 10,  766, 22,  2,  6,  2), 		 // 1059 mops, 6.2e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  769,  1, 22,  4,  3), 		 //   76 mops, 5.5e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  769,  1, 22,  4,  3), 		 //   76 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  805,  1, 22,  3,  4), 		 //   76 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  772,  1, 22,  4,  3), 		 //   76 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  820,  1, 22,  3,  4), 		 //   77 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  746,  2, 15,  5,  2), 		 //  107 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  746,  2, 15,  5,  2), 		 //  107 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  769,  2, 15,  4,  3), 		 //  107 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  769,  2, 15,  4,  3), 		 //  107 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  770,  2, 15,  4,  3), 		 //  108 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  775,  2, 15,  4,  3), 		 //  108 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  814,  2, 15,  4,  3), 		 //  113 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  747,  3, 11,  5,  2), 		 //  138 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  750,  3, 11,  5,  2), 		 //  139 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  779,  3, 11,  4,  3), 		 //  141 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  794,  2, 15,  4,  3), 		 //  157 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  783,  3, 12,  4,  3), 		 //  201 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  784,  3, 12,  4,  3), 		 //  201 mops, 5.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  787,  3, 12,  4,  3), 		 //  202 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  805,  3, 12,  4,  3), 		 //  206 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  756,  4,  9,  6,  2), 		 //  248 mops, 5.7e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  767,  4,  9,  6,  2), 		 //  251 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  760,  5,  8,  6,  2), 		 //  294 mops, 5.8e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  809,  5,  8,  6,  2), 		 //  312 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  763,  7,  6,  6,  2), 		 //  384 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  777,  8,  5,  6,  2), 		 //  436 mops, 5.8e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  771, 11,  4,  6,  2), 		 //  569 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  801, 14,  3,  6,  2), 		 //  731 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  834, 22,  2, 13,  1), 		 // 1186 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  857,  1, 22,  3,  4), 		 //   80 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  858,  1, 22,  3,  4), 		 //   80 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  861,  1, 22,  3,  4), 		 //   81 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  880,  1, 22,  3,  4), 		 //   82 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  821,  2, 15,  4,  3), 		 //  114 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  821,  2, 15,  4,  3), 		 //  114 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  821,  2, 15,  4,  3), 		 //  114 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  822,  2, 15,  4,  3), 		 //  114 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  823,  2, 15,  4,  3), 		 //  114 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  830,  2, 15,  4,  3), 		 //  115 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  910,  2, 15,  5,  3), 		 //  129 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  822,  3, 11,  4,  3), 		 //  148 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  824,  3, 11,  4,  3), 		 //  148 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  835,  3, 11,  4,  3), 		 //  150 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  853,  2, 15,  4,  3), 		 //  168 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  837,  3, 12,  4,  3), 		 //  214 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  838,  3, 12,  4,  3), 		 //  214 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  843,  3, 12,  4,  3), 		 //  216 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  875,  3, 12,  4,  3), 		 //  223 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  841,  4,  9,  4,  3), 		 //  264 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  860,  4,  9,  4,  3), 		 //  270 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  817,  5,  8,  6,  2), 		 //  315 mops, 5.7e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  819,  6,  7,  6,  2), 		 //  363 mops, 5.9e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  822,  7,  6,  6,  2), 		 //  413 mops, 5.8e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  838,  8,  5,  7,  2), 		 //  475 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  836, 11,  4,  6,  2), 		 //  616 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  846, 15,  3,  7,  2), 		 //  826 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  819, 44,  1, 13,  1), 		 // 2221 mops, 6.2e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  977,  1, 22,  3,  5), 		 //   91 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  987,  1, 22,  3,  5), 		 //   91 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  896,  2, 15,  5,  3), 		 //  127 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  896,  2, 15,  5,  3), 		 //  127 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  896,  2, 15,  5,  3), 		 //  127 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  896,  2, 15,  5,  3), 		 //  127 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  897,  2, 15,  5,  3), 		 //  128 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  900,  2, 15,  5,  3), 		 //  128 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  920,  2, 15,  5,  3), 		 //  131 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  896,  3, 11,  5,  3), 		 //  164 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  898,  3, 11,  5,  3), 		 //  165 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  903,  3, 11,  5,  3), 		 //  165 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  916,  3, 11,  7,  2), 		 //  175 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  873,  4,  9,  7,  2), 		 //  203 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  866,  5,  7,  7,  2), 		 //  237 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  913,  3, 12,  5,  3), 		 //  238 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  925,  3, 12,  5,  3), 		 //  241 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  913,  4,  9,  5,  3), 		 //  292 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  921,  4,  9,  5,  3), 		 //  294 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  884,  5,  8,  7,  2), 		 //  345 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  908,  5,  8,  7,  2), 		 //  354 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  921,  6,  7,  7,  2), 		 //  413 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  936,  7,  6,  8,  2), 		 //  480 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  891, 11,  4,  7,  2), 		 //  661 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  906, 14,  3,  7,  2), 		 //  831 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  917, 22,  2,  7,  2), 		 // 1271 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  964,  1, 22,  5,  3), 		 //  124 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  946,  2, 15,  5,  3), 		 //  174 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  946,  2, 15,  5,  3), 		 //  174 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  946,  2, 15,  5,  3), 		 //  174 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  947,  2, 15,  5,  3), 		 //  174 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  948,  2, 15,  5,  3), 		 //  174 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  954,  2, 15,  5,  3), 		 //  175 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  965,  2, 15,  8,  2), 		 //  188 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  947,  3, 11,  5,  3), 		 //  226 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  949,  3, 11,  5,  3), 		 //  226 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  958,  3, 11,  5,  3), 		 //  228 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  923,  4,  9,  7,  2), 		 //  278 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  964,  4,  9,  5,  3), 		 //  282 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  924,  5,  7,  7,  2), 		 //  329 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  936,  5,  7,  8,  2), 		 //  337 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  943,  6,  6,  8,  2), 		 //  391 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 11,  978,  4,  9,  5,  3), 		 //  466 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 11, 1005,  4,  9,  5,  3), 		 //  479 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 11,  991,  5,  8,  5,  3), 		 //  559 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 11,  958,  6,  7,  8,  2), 		 //  648 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 11,  962,  7,  6,  8,  2), 		 //  735 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 2, 11, 1003,  8,  5,  8,  2), 		 //  854 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 11,  996, 11,  4,  8,  2), 		 // 1111 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 11,  970, 21,  2,  8,  2), 		 // 1935 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 11,  985, 44,  1, 17,  1), 		 // 4025 mops, 6.3e-5 errors
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  993,  1, 23,  8,  2), 		 //  295 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  994,  1, 23,  8,  2), 		 //  295 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  999,  1, 23,  8,  2), 		 //  297 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 1, 12, 1014,  1, 23, 17,  1), 		 //  372 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 12, 1024,  2, 15,  6,  3), 		 //  408 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 1, 12, 1024,  2, 15,  6,  3), 		 //  408 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 12, 1024,  2, 15,  6,  3), 		 //  408 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  993,  2, 15,  8,  2), 		 //  411 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  994,  2, 15,  8,  2), 		 //  412 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  997,  2, 15,  8,  2), 		 //  413 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 12, 1018,  2, 15,  8,  2), 		 //  421 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  993,  3, 12,  8,  2), 		 //  528 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  996,  3, 12,  8,  2), 		 //  529 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 12, 1007,  3, 12,  8,  2), 		 //  535 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  994,  4,  9,  8,  2), 		 //  645 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  999,  4,  9,  8,  2), 		 //  648 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 12, 1014,  4,  9, 17,  1), 		 //  729 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 12, 1023,  5,  8,  8,  2), 		 //  783 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 12, 1008,  6,  7, 17,  1), 		 //  961 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 12, 1022,  7,  6, 17,  1), 		 // 1094 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 12, 1017, 10,  4,  9,  2), 		 // 1382 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 12, 1014, 14,  3,  8,  2), 		 // 1846 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 12, 1022, 22,  2,  9,  2), 		 // 2826 mops, 6.2e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_176

@@ -0,0 +1,275 @@
+{ /* Security level: 176 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  789,  1, 22,  3,  3), 		 //   75 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  800,  1, 22,  3,  3), 		 //   75 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  887,  1, 22,  4,  3), 		 //   86 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  786,  2, 15,  3,  3), 		 //  107 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  786,  2, 15,  3,  3), 		 //  107 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  787,  2, 15,  3,  3), 		 //  107 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  788,  2, 15,  3,  3), 		 //  107 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  792,  2, 15,  3,  3), 		 //  107 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  819,  1, 23,  3,  3), 		 //  109 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  897,  1, 23,  2,  5), 		 //  113 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  812,  2, 15,  3,  3), 		 //  156 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  812,  2, 15,  3,  3), 		 //  156 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  812,  2, 15,  3,  3), 		 //  156 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  812,  2, 15,  3,  3), 		 //  156 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  813,  2, 15,  3,  3), 		 //  156 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  765,  2, 15,  5,  2), 		 //  156 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  775,  2, 15,  5,  2), 		 //  158 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  763,  3, 12,  5,  2), 		 //  201 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  764,  3, 12,  5,  2), 		 //  201 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  767,  3, 12,  5,  2), 		 //  202 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  789,  3, 12,  5,  2), 		 //  207 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  766,  4,  9,  5,  2), 		 //  246 mops, 5.8e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  780,  4,  9,  5,  2), 		 //  251 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  771,  5,  8,  5,  2), 		 //  293 mops, 5.8e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  820,  5,  8,  6,  2), 		 //  316 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  775,  7,  6,  5,  2), 		 //  385 mops, 5.9e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  792,  8,  5,  5,  2), 		 //  440 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  785, 11,  4,  5,  2), 		 //  574 mops, 6.0e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  813, 14,  3,  6,  2), 		 //  742 mops, 6.1e-5 errors
+    /* 29 */ V0Parameter( 3, 10,  843, 22,  2, 12,  1), 		 // 1194 mops, 6.3e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  844,  1, 22,  4,  3), 		 //   83 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  809,  2, 15,  5,  2), 		 //  116 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  809,  2, 15,  5,  2), 		 //  116 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  809,  2, 15,  5,  2), 		 //  116 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  834,  2, 15,  4,  3), 		 //  116 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  835,  2, 15,  4,  3), 		 //  116 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  838,  2, 15,  4,  3), 		 //  116 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  892,  1, 23,  3,  4), 		 //  118 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  908,  1, 23,  3,  4), 		 //  120 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  849,  2, 15,  4,  3), 		 //  167 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  849,  2, 15,  4,  3), 		 //  167 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  849,  2, 15,  4,  3), 		 //  167 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  849,  2, 15,  4,  3), 		 //  167 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  850,  2, 15,  4,  3), 		 //  168 mops, 5.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  852,  2, 15,  4,  3), 		 //  168 mops, 5.5e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  862,  2, 15,  4,  3), 		 //  170 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  849,  3, 12,  4,  3), 		 //  217 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  850,  3, 12,  4,  3), 		 //  217 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  854,  3, 12,  4,  3), 		 //  218 mops, 5.8e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  877,  3, 12,  4,  3), 		 //  224 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  820,  4,  9,  6,  2), 		 //  268 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  834,  4,  9,  6,  2), 		 //  272 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  825,  5,  8,  6,  2), 		 //  318 mops, 5.7e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  905,  5,  8,  6,  2), 		 //  347 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  829,  7,  6,  6,  2), 		 //  416 mops, 5.8e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  846,  8,  5,  6,  2), 		 //  474 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  839, 11,  4,  6,  2), 		 //  618 mops, 5.9e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  884, 14,  3,  6,  2), 		 //  806 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  842, 43,  1, 12,  1), 		 // 2228 mops, 6.0e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  891,  2, 15,  4,  3), 		 //  123 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  891,  2, 15,  4,  3), 		 //  123 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  892,  2, 15,  4,  3), 		 //  123 mops, 5.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  892,  2, 15,  4,  3), 		 //  123 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  893,  2, 15,  4,  3), 		 //  124 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  897,  2, 15,  4,  3), 		 //  124 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  953,  1, 23,  3,  4), 		 //  125 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  980,  1, 23,  3,  4), 		 //  128 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  908,  2, 15,  4,  3), 		 //  178 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  908,  2, 15,  4,  3), 		 //  178 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  908,  2, 15,  4,  3), 		 //  178 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  909,  2, 15,  4,  3), 		 //  178 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  909,  2, 15,  4,  3), 		 //  178 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  912,  2, 15,  4,  3), 		 //  179 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  929,  2, 15,  4,  3), 		 //  182 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  909,  3, 12,  4,  3), 		 //  232 mops, 5.5e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  910,  3, 12,  4,  3), 		 //  232 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  916,  3, 12,  4,  3), 		 //  233 mops, 5.5e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  961,  3, 12,  4,  3), 		 //  244 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  914,  4,  9,  4,  3), 		 //  286 mops, 5.5e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  938,  4,  9,  4,  3), 		 //  294 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  888,  5,  8,  6,  2), 		 //  341 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  891,  6,  7,  6,  2), 		 //  394 mops, 5.9e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  894,  7,  6,  6,  2), 		 //  448 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  916,  8,  5,  7,  2), 		 //  518 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  905, 11,  4,  7,  2), 		 //  671 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  930, 15,  3,  7,  2), 		 //  907 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  895, 44,  1, 13,  1), 		 // 2426 mops, 6.0e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  978,  2, 15,  5,  3), 		 //  138 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  978,  2, 15,  5,  3), 		 //  138 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  979,  2, 15,  5,  3), 		 //  139 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  981,  2, 15,  5,  3), 		 //  139 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  996,  2, 15,  5,  3), 		 //  141 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10, 1009,  1, 23,  5,  3), 		 //  144 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  994,  2, 15,  5,  3), 		 //  200 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  994,  2, 15,  5,  3), 		 //  200 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  994,  2, 15,  5,  3), 		 //  200 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  994,  2, 15,  5,  3), 		 //  200 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  994,  2, 15,  5,  3), 		 //  200 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  996,  2, 15,  5,  3), 		 //  200 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 3, 10, 1005,  2, 15,  5,  3), 		 //  202 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  994,  3, 12,  5,  3), 		 //  258 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  995,  3, 12,  5,  3), 		 //  258 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  998,  3, 12,  5,  3), 		 //  259 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10, 1016,  3, 12,  5,  3), 		 //  264 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  997,  4,  9,  5,  3), 		 //  317 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10, 1009,  4,  9,  5,  3), 		 //  321 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  966,  5,  8,  7,  2), 		 //  376 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 3, 10, 1020,  5,  8,  7,  2), 		 //  396 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  969,  7,  6,  7,  2), 		 //  490 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  983,  8,  5,  7,  2), 		 //  555 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  977, 11,  4,  7,  2), 		 //  723 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 3, 10, 1001, 14,  3,  8,  2), 		 //  923 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 3, 10, 1008, 22,  2, 15,  1), 		 // 1443 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11, 1005,  2, 15,  7,  2), 		 //  192 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 11, 1006,  2, 15,  7,  2), 		 //  192 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 11, 1012,  2, 15,  7,  2), 		 //  193 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 11, 1015,  2, 15, 15,  1), 		 //  226 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 11, 1005,  3, 11,  7,  2), 		 //  247 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 11, 1007,  3, 11,  7,  2), 		 //  247 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 11, 1016,  3, 11,  7,  2), 		 //  250 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11, 1008,  4,  9,  7,  2), 		 //  303 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 11, 1022,  4,  9,  7,  2), 		 //  307 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 1, 11, 1009,  5,  7,  7,  2), 		 //  358 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 11, 1015,  5,  7,  8,  2), 		 //  364 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 12, 1004,  2, 15,  7,  2), 		 //  408 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 11, 1013,  3, 12, 15,  1), 		 //  473 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 11, 1015,  3, 12, 15,  1), 		 //  474 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 11, 1022,  3, 12, 16,  1), 		 //  485 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 11, 1014,  4,  9, 15,  1), 		 //  562 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 11, 1019,  4,  9, 15,  1), 		 //  565 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 11, 1017,  5,  8, 15,  1), 		 //  653 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 2, 11, 1018,  6,  7, 15,  1), 		 //  743 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 11, 1019,  7,  6, 15,  1), 		 //  834 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 11, 1023,  8,  5, 15,  1), 		 //  927 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 11, 1023, 11,  4, 15,  1), 		 // 1197 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 11, 1020, 21,  2, 15,  1), 		 // 2090 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 11, 1024, 43,  1, 16,  1), 		 // 4086 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_192

@@ -0,0 +1,275 @@
+{ /* Security level: 192 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  867,  2, 15,  3,  3), 		 //  117 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  867,  2, 15,  3,  3), 		 //  117 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  867,  2, 15,  3,  3), 		 //  117 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  869,  2, 15,  3,  3), 		 //  117 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  876,  2, 15,  3,  3), 		 //  118 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  894,  1, 23,  3,  3), 		 //  118 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  894,  1, 23,  3,  3), 		 //  118 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  896,  1, 23,  3,  3), 		 //  118 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  902,  1, 23,  3,  3), 		 //  119 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  940,  1, 23,  3,  4), 		 //  124 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  894,  2, 15,  3,  3), 		 //  170 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  894,  2, 15,  3,  3), 		 //  170 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  894,  2, 15,  3,  3), 		 //  170 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  894,  2, 15,  3,  3), 		 //  170 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  895,  2, 15,  3,  3), 		 //  171 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  900,  2, 15,  3,  3), 		 //  171 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  857,  2, 15,  5,  2), 		 //  174 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  842,  3, 12,  5,  2), 		 //  220 mops, 5.5e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  843,  3, 12,  5,  2), 		 //  221 mops, 5.5e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  847,  3, 12,  5,  2), 		 //  222 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  875,  3, 12,  5,  2), 		 //  229 mops, 5.9e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  846,  4,  9,  5,  2), 		 //  271 mops, 5.5e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  863,  4,  9,  5,  2), 		 //  276 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  852,  5,  8,  5,  2), 		 //  323 mops, 5.5e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  928,  5,  8,  6,  2), 		 //  356 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  857,  7,  6,  5,  2), 		 //  425 mops, 5.6e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  879,  8,  5,  5,  2), 		 //  487 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  869, 11,  4,  5,  2), 		 //  634 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  911, 14,  3,  6,  2), 		 //  830 mops, 6.3e-5 errors
+    /* 29 */ V0Parameter( 3, 10,  868, 43,  1, 11,  1), 		 // 2292 mops, 6.3e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  918,  2, 15,  4,  3), 		 //  127 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  918,  2, 15,  4,  3), 		 //  127 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  919,  2, 15,  4,  3), 		 //  127 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  924,  2, 15,  4,  3), 		 //  128 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  976,  1, 23,  3,  4), 		 //  128 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  976,  1, 23,  3,  4), 		 //  128 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  977,  1, 23,  3,  4), 		 //  128 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  980,  1, 23,  3,  4), 		 //  128 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 3, 10, 1000,  1, 23,  3,  4), 		 //  131 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  934,  2, 15,  4,  3), 		 //  183 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  934,  2, 15,  4,  3), 		 //  183 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  934,  2, 15,  4,  3), 		 //  183 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  934,  2, 15,  4,  3), 		 //  183 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  935,  2, 15,  4,  3), 		 //  183 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  937,  2, 15,  4,  3), 		 //  184 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  950,  2, 15,  4,  3), 		 //  186 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  934,  3, 12,  4,  3), 		 //  238 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  935,  3, 12,  4,  3), 		 //  238 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  940,  3, 12,  4,  3), 		 //  239 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  969,  3, 12,  4,  3), 		 //  246 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  938,  4,  9,  4,  3), 		 //  294 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  921,  4,  9,  6,  2), 		 //  299 mops, 5.8e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  909,  5,  8,  6,  2), 		 //  349 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  912,  6,  7,  6,  2), 		 //  403 mops, 5.6e-5 errors
+    /* 24 */ V0Parameter( 3, 10,  914,  7,  6,  6,  2), 		 //  458 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 3, 10,  937,  8,  5,  6,  2), 		 //  524 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  927, 11,  4,  6,  2), 		 //  681 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  947, 15,  3,  6,  2), 		 //  918 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 3, 10,  915, 44,  1, 12,  1), 		 // 2474 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  981,  2, 15,  4,  3), 		 //  135 mops, 5.5e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  982,  2, 15,  4,  3), 		 //  135 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  989,  2, 15,  4,  3), 		 //  136 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  998,  1, 23,  4,  3), 		 //  136 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  999,  1, 23,  4,  3), 		 //  136 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 3, 10, 1000,  1, 23,  4,  3), 		 //  137 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 3, 10, 1005,  1, 23,  4,  3), 		 //  137 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  999,  1, 23,  6,  2), 		 //  148 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  998,  2, 15,  4,  3), 		 //  195 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  998,  2, 15,  4,  3), 		 //  195 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  998,  2, 15,  4,  3), 		 //  195 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  998,  2, 15,  4,  3), 		 //  195 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  999,  2, 15,  4,  3), 		 //  195 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10, 1003,  2, 15,  4,  3), 		 //  196 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10, 1024,  2, 15,  4,  3), 		 //  200 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  999,  3, 12,  4,  3), 		 //  253 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 3, 10, 1000,  3, 12,  4,  3), 		 //  254 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 3, 10, 1007,  3, 12,  4,  3), 		 //  255 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 3, 10, 1010,  3, 12,  7,  2), 		 //  274 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10, 1005,  4,  9,  4,  3), 		 //  314 mops, 5.6e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  999,  4,  9,  6,  2), 		 //  324 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  978,  5,  8,  6,  2), 		 //  374 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  982,  6,  7,  6,  2), 		 //  434 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  987,  7,  6,  6,  2), 		 //  493 mops, 6.0e-5 errors
+    /* 24 */ V0Parameter( 3, 10, 1019,  8,  5,  7,  2), 		 //  575 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 3, 10, 1001, 11,  4,  7,  2), 		 //  741 mops, 6.1e-5 errors
+    /* 26 */ V0Parameter( 3, 10,  998, 21,  2,  7,  2), 		 // 1323 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 3, 10,  993, 44,  1, 13,  1), 		 // 2690 mops, 6.1e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 11, 1020,  2, 15,  6,  2), 		 //  191 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 11, 1014,  2, 15,  7,  2), 		 //  194 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10, 1024,  3, 11, 14,  1), 		 //  223 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10, 1024,  4,  9, 14,  1), 		 //  265 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 2, 11, 1021,  1, 23, 13,  1), 		 //  281 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 11, 1018,  2, 15, 13,  1), 		 //  370 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 11, 1018,  2, 15, 13,  1), 		 //  370 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 11, 1018,  2, 15, 13,  1), 		 //  370 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 11, 1018,  2, 15, 13,  1), 		 //  370 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 11, 1018,  2, 15, 13,  1), 		 //  370 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 11, 1019,  2, 15, 13,  1), 		 //  370 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 11, 1020,  2, 15, 13,  1), 		 //  370 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 11, 1022,  2, 15, 14,  1), 		 //  379 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 11, 1019,  3, 12, 13,  1), 		 //  459 mops, 5.5e-5 errors
+    /* 14 */ V0Parameter( 2, 11, 1019,  3, 12, 13,  1), 		 //  459 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 11, 1023,  3, 12, 13,  1), 		 //  461 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 11, 1019,  4,  9, 13,  1), 		 //  549 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 11, 1021,  4,  9, 13,  1), 		 //  550 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 11, 1020,  5,  8, 13,  1), 		 //  639 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 11, 1021,  5,  8, 14,  1), 		 //  648 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 11, 1023,  6,  7, 14,  1), 		 //  739 mops, 5.7e-5 errors
+    /* 21 */ V0Parameter( 2, 11, 1024,  7,  6, 14,  1), 		 //  830 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 11, 1022, 10,  4, 14,  1), 		 // 1098 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 11, 1020, 14,  3, 14,  1), 		 // 1454 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 2, 11, 1022, 22,  2, 14,  1), 		 // 2175 mops, 6.1e-5 errors
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_256

@@ -0,0 +1,275 @@
+{ /* Security level: 256 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_80

@@ -0,0 +1,275 @@
+{ /* Security level: 80 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  512,  1, 22,  1,  9), 		 //   29 mops, 1.8e-15 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  1, 22,  1,  9), 		 //   29 mops, 3.7e-15 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  1, 22,  1,  9), 		 //   29 mops, 4.5e-14 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  1, 22,  1,  9), 		 //   29 mops, 5.2e-11 errors
+    /*  4 */ V0Parameter( 1, 10,  512,  1, 22,  1,  9), 		 //   29 mops, 2.9e-6 errors
+    /*  5 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 1.4e-15 errors
+    /*  6 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 1.6e-15 errors
+    /*  7 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 2.3e-15 errors
+    /*  8 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 8.9e-15 errors
+    /*  9 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 7.4e-13 errors
+    /* 10 */ V0Parameter( 1, 10,  512,  2, 15,  1,  9), 		 //   42 mops, 1.2e-8 errors
+    /* 11 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 5.0e-5 errors
+    /* 12 */ V0Parameter( 1, 10,  512,  3, 11,  1,  9), 		 //   55 mops, 2.1e-14 errors
+    /* 13 */ V0Parameter( 1, 10,  512,  3, 11,  1,  9), 		 //   55 mops, 7.5e-12 errors
+    /* 14 */ V0Parameter( 1, 10,  512,  3, 11,  1,  9), 		 //   55 mops, 3.2e-7 errors
+    /* 15 */ V0Parameter( 1, 10,  512,  4,  9,  1,  9), 		 //   68 mops, 5.2e-11 errors
+    /* 16 */ V0Parameter( 1, 10,  512,  4,  9,  1,  9), 		 //   68 mops, 2.9e-6 errors
+    /* 17 */ V0Parameter( 2, 10,  512,  2, 16,  1,  9), 		 //   68 mops, 2.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  1,  9), 		 //   89 mops, 1.9e-8 errors
+    /* 19 */ V0Parameter( 2, 10,  512,  3, 12,  1,  9), 		 //   89 mops, 4.3e-8 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  3, 12,  1,  9), 		 //   89 mops, 6.1e-7 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 2.3e-7 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  4,  9,  1,  9), 		 //  110 mops, 4.4e-7 errors
+    /* 23 */ V0Parameter( 2, 10,  515,  4,  9,  1,  9), 		 //  111 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  5,  8,  1,  9), 		 //  131 mops, 3.1e-6 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  5,  8,  2,  6), 		 //  133 mops, 5.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  512,  7,  6,  1,  9), 		 //  173 mops, 1.1e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  512,  8,  5,  2,  6), 		 //  196 mops, 2.6e-6 errors
+    /* 28 */ V0Parameter( 2, 10,  515, 11,  4,  1,  9), 		 //  258 mops, 6.1e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  512, 14,  3,  3,  5), 		 //  324 mops, 6.2e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  512, 43,  1,  2,  6), 		 //  931 mops, 1.5e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  513,  1, 22,  1,  9), 		 //   29 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  515,  1, 22,  1,  9), 		 //   29 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  522,  1, 22,  1,  9), 		 //   29 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  1, 22,  2,  6), 		 //   30 mops, 3.1e-8 errors
+    /*  4 */ V0Parameter( 1, 10,  513,  2, 15,  1,  9), 		 //   42 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 1, 10,  513,  2, 15,  1,  9), 		 //   42 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 1, 10,  513,  2, 15,  1,  9), 		 //   42 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 10,  514,  2, 15,  1,  9), 		 //   42 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 1, 10,  517,  2, 15,  1,  9), 		 //   42 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 4.8e-14 errors
+    /* 10 */ V0Parameter( 1, 10,  512,  2, 15,  3,  5), 		 //   44 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 10,  514,  3, 11,  1,  9), 		 //   55 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 10,  519,  3, 11,  1,  9), 		 //   55 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 2.8e-10 errors
+    /* 14 */ V0Parameter( 1, 10,  512,  4,  9,  2,  6), 		 //   69 mops, 0.0e0 errors
+    /* 15 */ V0Parameter( 1, 10,  512,  4,  9,  2,  6), 		 //   69 mops, 3.1e-8 errors
+    /* 16 */ V0Parameter( 2, 10,  512,  2, 16,  2,  6), 		 //   70 mops, 3.3e-9 errors
+    /* 17 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 0.0e0 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 0.0e0 errors
+    /* 19 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 0.0e0 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 6.3e-7 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  4,  9,  2,  6), 		 //  112 mops, 0.0e0 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  4,  9,  2,  6), 		 //  112 mops, 1.6e-7 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  5,  8,  2,  6), 		 //  133 mops, 3.1e-13 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  5,  8,  3,  5), 		 //  135 mops, 5.7e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  7,  6,  2,  6), 		 //  175 mops, 1.9e-10 errors
+    /* 26 */ V0Parameter( 2, 10,  512,  8,  5,  2,  6), 		 //  196 mops, 5.2e-6 errors
+    /* 27 */ V0Parameter( 2, 10,  512, 11,  4,  2,  6), 		 //  259 mops, 1.6e-7 errors
+    /* 28 */ V0Parameter( 2, 10,  512, 15,  3,  2,  6), 		 //  343 mops, 5.1e-6 errors
+    /* 29 */ V0Parameter( 2, 10,  512, 43,  1,  2,  6), 		 //  931 mops, 2.5e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  512,  1, 22,  2,  6), 		 //   30 mops, 0.0e0 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  1, 22,  2,  6), 		 //   30 mops, 6.9e-14 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  1, 22,  2,  6), 		 //   30 mops, 6.5e-7 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 0.0e0 errors
+    /*  4 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 0.0e0 errors
+    /*  5 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 0.0e0 errors
+    /*  6 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 0.0e0 errors
+    /*  7 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 0.0e0 errors
+    /*  8 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 3.3e-10 errors
+    /*  9 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 0.0e0 errors
+    /* 10 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 0.0e0 errors
+    /* 11 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 2.3e-15 errors
+    /* 12 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 3.4e-8 errors
+    /* 13 */ V0Parameter( 1, 10,  512,  4,  9,  2,  6), 		 //   69 mops, 6.9e-14 errors
+    /* 14 */ V0Parameter( 1, 10,  512,  4,  9,  2,  6), 		 //   69 mops, 6.4e-7 errors
+    /* 15 */ V0Parameter( 2, 10,  512,  2, 16,  2,  6), 		 //   70 mops, 6.0e-7 errors
+    /* 16 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 2.4e-15 errors
+    /* 17 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 5.3e-14 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 1.7e-10 errors
+    /* 19 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 1.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  4,  9,  2,  6), 		 //  112 mops, 7.1e-11 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  4,  9,  2,  6), 		 //  112 mops, 5.0e-6 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  5,  8,  2,  6), 		 //  133 mops, 9.5e-9 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  6,  7,  2,  6), 		 //  154 mops, 3.8e-8 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  7,  6,  2,  6), 		 //  175 mops, 1.5e-7 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  8,  5,  2,  6), 		 //  196 mops, 4.2e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  512, 11,  4,  2,  6), 		 //  259 mops, 4.9e-6 errors
+    /* 27 */ V0Parameter( 2, 10,  512, 15,  3,  2,  6), 		 //  343 mops, 4.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  512, 43,  1,  3,  5), 		 //  933 mops, 4.1e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  512,  1, 22,  2,  6), 		 //   30 mops, 5.9e-6 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  1, 22,  3,  5), 		 //   31 mops, 2.0e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 8.5e-7 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 8.6e-7 errors
+    /*  4 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 9.1e-7 errors
+    /*  5 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 1.1e-6 errors
+    /*  6 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 2.4e-6 errors
+    /*  7 */ V0Parameter( 1, 10,  512,  2, 15,  2,  6), 		 //   43 mops, 2.5e-5 errors
+    /*  8 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 9.4e-7 errors
+    /*  9 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 1.3e-6 errors
+    /* 10 */ V0Parameter( 1, 10,  512,  3, 11,  2,  6), 		 //   56 mops, 3.8e-6 errors
+    /* 11 */ V0Parameter( 1, 10,  515,  3, 11,  2,  6), 		 //   56 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 10,  512,  4,  9,  2,  6), 		 //   69 mops, 5.9e-6 errors
+    /* 13 */ V0Parameter( 1, 10,  512,  4,  9,  3,  5), 		 //   70 mops, 2.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  2, 16,  3,  5), 		 //   72 mops, 1.5e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  512,  3, 12,  2,  6), 		 //   91 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  514,  3, 12,  2,  6), 		 //   91 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  523,  3, 12,  2,  6), 		 //   93 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  4,  4), 		 //   95 mops, 4.4e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  521,  4,  9,  2,  6), 		 //  114 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  4,  9,  3,  5), 		 //  114 mops, 5.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  5,  8,  3,  5), 		 //  135 mops, 1.7e-6 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  6,  7,  3,  5), 		 //  156 mops, 3.4e-6 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  7,  6,  3,  5), 		 //  177 mops, 7.0e-6 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  9,  5,  3,  5), 		 //  219 mops, 2.0e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  512, 11,  4,  3,  5), 		 //  261 mops, 5.3e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  512, 21,  2,  4,  4), 		 //  473 mops, 4.3e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  512, 44,  1,  4,  4), 		 //  956 mops, 5.1e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 1.1e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 1.2e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 1.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 1.3e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 1.7e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  512,  1, 23,  3,  5), 		 //   66 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  528,  1, 23,  4,  4), 		 //   69 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 1.1e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 1.2e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 1.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 1.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 1.6e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  512,  2, 15,  3,  5), 		 //   94 mops, 3.8e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  512,  2, 15,  4,  4), 		 //   96 mops, 4.0e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  512,  3, 12,  3,  5), 		 //  122 mops, 1.3e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  512,  3, 12,  3,  5), 		 //  122 mops, 1.9e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  513,  3, 12,  3,  5), 		 //  122 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  512,  4,  9,  3,  5), 		 //  150 mops, 1.7e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  512,  4,  9,  3,  5), 		 //  150 mops, 5.0e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  512,  4,  9,  5,  3), 		 //  154 mops, 5.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  518,  5,  8,  3,  5), 		 //  180 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  512,  6,  7,  4,  4), 		 //  208 mops, 1.4e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  512,  7,  6,  4,  4), 		 //  236 mops, 2.8e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  512,  9,  5,  5,  3), 		 //  294 mops, 3.4e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  512, 11,  4, 16,  1), 		 //  372 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  512, 21,  2,  9,  2), 		 //  638 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  526,  1, 23,  4,  4), 		 //  147 mops, 4.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  526,  1, 23,  4,  4), 		 //  147 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  526,  1, 23,  4,  4), 		 //  147 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  529,  1, 23,  4,  4), 		 //  148 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  553,  1, 23,  4,  4), 		 //  154 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 2.7e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 2.7e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 2.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 2.9e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 3.3e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  512,  2, 15,  5,  3), 		 //  208 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  527,  2, 15,  5,  3), 		 //  213 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  512,  3, 12,  5,  3), 		 //  268 mops, 3.1e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  512,  3, 12,  5,  3), 		 //  268 mops, 4.4e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  518,  3, 12,  5,  3), 		 //  271 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  512,  4,  9,  5,  3), 		 //  328 mops, 3.6e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  513,  4,  9,  5,  3), 		 //  328 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  512,  4,  9,  8,  2), 		 //  340 mops, 5.6e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  520,  5,  8,  6,  3), 		 //  397 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  512,  6,  7,  8,  2), 		 //  460 mops, 4.1e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  515,  7,  6,  8,  2), 		 //  523 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  512, 10,  4,  8,  2), 		 //  700 mops, 2.1e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  512, 14,  3,  8,  2), 		 //  940 mops, 1.1e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  519, 21,  2,  9,  2), 		 // 1382 mops, 6.2e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  578,  1, 23,  4,  4), 		 //  339 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  549,  1, 23,  6,  3), 		 //  340 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  567,  1, 23,  6,  3), 		 //  351 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  545,  2, 15,  6,  3), 		 //  474 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  545,  2, 15,  6,  3), 		 //  474 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  545,  2, 15,  6,  3), 		 //  474 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  545,  2, 15,  6,  3), 		 //  474 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  546,  2, 15,  6,  3), 		 //  475 mops, 5.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  547,  2, 15,  6,  3), 		 //  476 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  555,  2, 15,  6,  3), 		 //  483 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  546,  3, 11,  6,  3), 		 //  612 mops, 4.9e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  546,  3, 11,  6,  3), 		 //  612 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  550,  3, 11,  6,  3), 		 //  616 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  546,  4,  9,  6,  3), 		 //  748 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  549,  4,  9,  6,  3), 		 //  752 mops, 5.1e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  567,  4,  9,  6,  3), 		 //  776 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  548,  5,  8,  9,  2), 		 //  914 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  558,  6,  7,  9,  2), 		 // 1069 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  535,  8,  5,  9,  2), 		 // 1294 mops, 5.8e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  540, 10,  4,  9,  2), 		 // 1576 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  541, 14,  3,  9,  2), 		 // 2120 mops, 5.7e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  562, 21,  2, 10,  2), 		 // 3193 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  618,  1, 22,  5,  4), 		 //  778 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  588,  2, 15,  6,  3), 		 // 1074 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  588,  2, 15,  6,  3), 		 // 1074 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  588,  2, 15,  6,  3), 		 // 1074 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  588,  2, 15,  6,  3), 		 // 1074 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  589,  2, 15,  6,  3), 		 // 1076 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  591,  2, 15,  6,  3), 		 // 1080 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  615,  2, 15,  5,  4), 		 // 1102 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  589,  3, 11,  6,  3), 		 // 1389 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  590,  3, 11,  6,  3), 		 // 1391 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  594,  3, 11,  6,  3), 		 // 1400 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  622,  3, 11,  7,  3), 		 // 1483 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  593,  4,  9,  6,  3), 		 // 1713 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  611,  4,  9,  7,  3), 		 // 1782 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  601,  5,  8, 10,  2), 		 // 2130 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  574,  7,  6, 10,  2), 		 // 2647 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  576,  8,  5, 10,  2), 		 // 2962 mops, 5.5e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  580, 10,  4, 10,  2), 		 // 3598 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  584, 14,  3, 10,  2), 		 // 4864 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 14,  612, 22,  2, 21,  1), 		 // 7906 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_2022-6-27_96

@@ -0,0 +1,275 @@
+{ /* Security level: 96 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  512,  1, 12,  2,  5), 		 //   30 mops, 8.0e-6 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 0.0e0 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 0.0e0 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 3.2e-13 errors
+    /*  4 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 8.0e-6 errors
+    /*  5 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 7.0e-15 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 8.3e-15 errors
+    /*  7 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 1.7e-14 errors
+    /*  8 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 2.0e-13 errors
+    /*  9 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 1.8e-10 errors
+    /* 10 */ V0Parameter( 2, 10,  512,  1, 23,  2,  5), 		 //   49 mops, 6.3e-6 errors
+    /* 11 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 6.7e-15 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 6.9e-15 errors
+    /* 13 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 7.9e-15 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 1.3e-14 errors
+    /* 15 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 9.3e-14 errors
+    /* 16 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 3.1e-11 errors
+    /* 17 */ V0Parameter( 2, 10,  512,  2, 16,  2,  5), 		 //   70 mops, 8.4e-7 errors
+    /* 18 */ V0Parameter( 2, 10,  512,  3, 12,  2,  5), 		 //   91 mops, 1.9e-14 errors
+    /* 19 */ V0Parameter( 2, 10,  512,  3, 12,  2,  5), 		 //   91 mops, 2.8e-13 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  3, 12,  2,  5), 		 //   91 mops, 4.1e-10 errors
+    /* 21 */ V0Parameter( 2, 10,  512,  3, 12,  2,  5), 		 //   91 mops, 1.4e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  4,  9,  2,  5), 		 //  112 mops, 1.8e-10 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  4,  9,  2,  5), 		 //  112 mops, 6.3e-6 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  5,  8,  2,  5), 		 //  133 mops, 1.7e-8 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  5,  8,  4,  3), 		 //  137 mops, 5.9e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  512,  7,  6,  2,  5), 		 //  175 mops, 2.2e-7 errors
+    /* 27 */ V0Parameter( 2, 10,  512,  8,  5,  2,  5), 		 //  196 mops, 5.0e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  512, 11,  4,  2,  5), 		 //  259 mops, 6.3e-6 errors
+    /* 29 */ V0Parameter( 2, 10,  512, 15,  3,  2,  5), 		 //  343 mops, 5.0e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  512, 43,  1,  3,  4), 		 //  933 mops, 2.9e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 6.5e-8 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 1.5e-7 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2,  8,  2,  5), 		 //   43 mops, 1.9e-6 errors
+    /*  3 */ V0Parameter( 1, 10,  512,  2,  8,  3,  4), 		 //   44 mops, 1.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  514,  1, 23,  2,  5), 		 //   49 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  514,  1, 23,  2,  5), 		 //   49 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  1, 23,  2,  5), 		 //   49 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  515,  1, 23,  2,  5), 		 //   49 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  519,  1, 23,  2,  5), 		 //   50 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  512,  1, 23,  3,  4), 		 //   51 mops, 1.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  514,  2, 16,  2,  5), 		 //   70 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  514,  2, 16,  2,  5), 		 //   70 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  514,  2, 16,  2,  5), 		 //   70 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  514,  2, 16,  2,  5), 		 //   70 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  515,  2, 16,  2,  5), 		 //   70 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  518,  2, 16,  2,  5), 		 //   71 mops, 5.4e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  512,  2, 16,  3,  4), 		 //   72 mops, 1.8e-6 errors
+    /* 17 */ V0Parameter( 2, 10,  515,  3, 12,  2,  5), 		 //   92 mops, 4.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  515,  3, 12,  2,  5), 		 //   92 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  520,  3, 12,  2,  5), 		 //   92 mops, 5.4e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  512,  3, 12,  3,  4), 		 //   93 mops, 2.2e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  519,  4,  9,  2,  5), 		 //  113 mops, 5.8e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  4,  9,  3,  4), 		 //  114 mops, 1.1e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  5,  8,  3,  4), 		 //  135 mops, 6.1e-8 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  6,  7,  3,  4), 		 //  156 mops, 1.8e-7 errors
+    /* 25 */ V0Parameter( 2, 10,  512,  7,  6,  3,  4), 		 //  177 mops, 5.6e-7 errors
+    /* 26 */ V0Parameter( 2, 10,  514,  8,  5,  3,  4), 		 //  199 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  512, 11,  4,  3,  4), 		 //  261 mops, 1.1e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  514, 15,  3,  3,  4), 		 //  346 mops, 6.0e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  512, 43,  1,  4,  3), 		 //  935 mops, 4.8e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  512,  2,  8,  3,  4), 		 //   44 mops, 1.6e-6 errors
+    /*  1 */ V0Parameter( 1, 10,  512,  2,  8,  3,  4), 		 //   44 mops, 1.0e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  512,  2,  8,  4,  3), 		 //   45 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  518,  1, 23,  3,  4), 		 //   52 mops, 4.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  518,  1, 23,  3,  4), 		 //   52 mops, 4.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  518,  1, 23,  3,  4), 		 //   52 mops, 4.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  518,  1, 23,  3,  4), 		 //   52 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  521,  1, 23,  3,  4), 		 //   52 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  516,  1, 23,  4,  3), 		 //   53 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  518,  2, 16,  3,  4), 		 //   73 mops, 4.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  518,  2, 16,  3,  4), 		 //   73 mops, 4.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  518,  2, 16,  3,  4), 		 //   73 mops, 4.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  518,  2, 16,  3,  4), 		 //   73 mops, 4.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  518,  2, 16,  3,  4), 		 //   73 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  520,  2, 16,  3,  4), 		 //   73 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  512,  2, 16,  4,  3), 		 //   74 mops, 3.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  518,  3, 12,  3,  4), 		 //   94 mops, 5.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  518,  3, 12,  3,  4), 		 //   94 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522,  3, 12,  3,  4), 		 //   95 mops, 5.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  521,  3, 12,  4,  3), 		 //   97 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  521,  4,  9,  3,  4), 		 //  116 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  516,  4,  9,  4,  3), 		 //  117 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  512,  5,  8,  4,  3), 		 //  137 mops, 4.9e-6 errors
+    /* 23 */ V0Parameter( 2, 10,  512,  6,  7,  4,  3), 		 //  158 mops, 8.8e-6 errors
+    /* 24 */ V0Parameter( 2, 10,  512,  7,  6,  4,  3), 		 //  179 mops, 1.6e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  517,  8,  5,  6,  2), 		 //  206 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  516, 11,  4,  4,  3), 		 //  265 mops, 5.8e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  512, 15,  3,  7,  2), 		 //  353 mops, 4.8e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  512, 44,  1,  6,  2), 		 //  960 mops, 2.8e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  530,  2,  8,  4,  3), 		 //   46 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  569,  1, 23,  3,  4), 		 //   56 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  569,  1, 23,  3,  4), 		 //   56 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  569,  1, 23,  3,  4), 		 //   56 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  569,  1, 23,  3,  4), 		 //   56 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  572,  1, 23,  3,  4), 		 //   56 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  559,  1, 23,  4,  3), 		 //   57 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  545,  2, 16,  4,  3), 		 //   78 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  2, 16,  4,  3), 		 //   78 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  545,  2, 16,  4,  3), 		 //   78 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  545,  2, 16,  4,  3), 		 //   78 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  545,  2, 16,  4,  3), 		 //   78 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  547,  2, 16,  4,  3), 		 //   79 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  554,  2, 16,  4,  3), 		 //   79 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  559,  2, 16,  5,  3), 		 //   82 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  546,  3, 12,  4,  3), 		 //  101 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  535,  3, 12,  5,  3), 		 //  101 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  540,  3, 12,  5,  3), 		 //  102 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  515,  4,  9,  7,  2), 		 //  123 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  519,  4,  9,  7,  2), 		 //  124 mops, 5.6e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  516,  5,  8,  7,  2), 		 //  144 mops, 5.7e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  524,  5,  8,  7,  2), 		 //  146 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  527,  6,  7,  7,  2), 		 //  169 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  531,  7,  6,  7,  2), 		 //  192 mops, 6.0e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  541,  9,  5,  7,  2), 		 //  239 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  553, 11,  4, 15,  1), 		 //  307 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  527, 22,  2,  7,  2), 		 //  514 mops, 5.8e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  565,  1, 23,  5,  3), 		 //   76 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  565,  1, 23,  5,  3), 		 //   76 mops, 5.2e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  565,  1, 23,  5,  3), 		 //   76 mops, 5.3e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  565,  1, 23,  5,  3), 		 //   76 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  566,  1, 23,  5,  3), 		 //   76 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  571,  1, 23,  5,  3), 		 //   77 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  565,  2, 15,  5,  3), 		 //  107 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  565,  2, 15,  5,  3), 		 //  107 mops, 5.2e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  565,  2, 15,  5,  3), 		 //  107 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  565,  2, 15,  5,  3), 		 //  107 mops, 5.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  565,  2, 15,  5,  3), 		 //  107 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  566,  2, 15,  5,  3), 		 //  107 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  570,  2, 15,  5,  3), 		 //  108 mops, 5.4e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  586,  2, 15,  8,  2), 		 //  117 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  565,  3, 12,  5,  3), 		 //  138 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  566,  3, 12,  5,  3), 		 //  138 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  573,  3, 12,  5,  3), 		 //  140 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  548,  4,  9,  7,  2), 		 //  168 mops, 5.3e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  553,  4,  9,  7,  2), 		 //  170 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  549,  5,  8,  7,  2), 		 //  198 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  566,  5,  8,  7,  2), 		 //  204 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  567,  6,  7,  8,  2), 		 //  238 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  576,  7,  6,  8,  2), 		 //  273 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  554, 11,  4,  7,  2), 		 //  382 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  561, 14,  3,  8,  2), 		 //  481 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  566, 22,  2,  8,  2), 		 //  733 mops, 6.1e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  635,  1, 23,  4,  4), 		 //  174 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  635,  1, 23,  4,  4), 		 //  174 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  636,  1, 23,  4,  4), 		 //  175 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  641,  1, 23,  4,  4), 		 //  176 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  616,  2, 15,  5,  3), 		 //  247 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  616,  2, 15,  5,  3), 		 //  247 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  616,  2, 15,  5,  3), 		 //  247 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  616,  2, 15,  5,  3), 		 //  247 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  616,  2, 15,  5,  3), 		 //  247 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  617,  2, 15,  5,  3), 		 //  247 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  621,  2, 15,  5,  3), 		 //  248 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  635,  2, 15,  6,  3), 		 //  259 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  617,  3, 12,  5,  3), 		 //  319 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  619,  3, 12,  5,  3), 		 //  320 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  604,  3, 12,  8,  2), 		 //  327 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  594,  4,  9,  8,  2), 		 //  391 mops, 5.3e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  598,  4,  9,  8,  2), 		 //  394 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  596,  5,  8,  8,  2), 		 //  463 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  621,  5,  8,  8,  2), 		 //  481 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  633,  6,  7,  9,  2), 		 //  569 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  602,  8,  5,  8,  2), 		 //  679 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  620, 10,  4,  8,  2), 		 //  844 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  611, 14,  3,  8,  2), 		 // 1118 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  626, 22,  2,  9,  2), 		 // 1737 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  660,  1, 23,  6,  3), 		 //  403 mops, 5.5e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  664,  1, 23,  6,  3), 		 //  405 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 5.2e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 5.2e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 5.2e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  659,  2, 15,  6,  3), 		 //  567 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  662,  2, 15,  6,  3), 		 //  570 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  677,  2, 15,  6,  3), 		 //  582 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  659,  3, 11,  6,  3), 		 //  732 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  660,  3, 11,  6,  3), 		 //  733 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  667,  3, 11,  6,  3), 		 //  740 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  660,  4,  9,  6,  3), 		 //  898 mops, 5.5e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  664,  4,  9,  6,  3), 		 //  903 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  644,  5,  8,  9,  2), 		 // 1068 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  646,  6,  7,  9,  2), 		 // 1233 mops, 5.4e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  647,  7,  6,  9,  2), 		 // 1396 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  650,  8,  5,  9,  2), 		 // 1565 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  661, 10,  4,  9,  2), 		 // 1922 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  663, 14,  3,  9,  2), 		 // 2590 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  652, 42,  1, 19,  1), 		 // 7214 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  759,  1, 22,  5,  4), 		 //  941 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  711,  2, 15,  6,  3), 		 // 1286 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  711,  2, 15,  6,  3), 		 // 1286 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  711,  2, 15,  6,  3), 		 // 1286 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  711,  2, 15,  6,  3), 		 // 1286 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  712,  2, 15,  6,  3), 		 // 1288 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  716,  2, 15,  6,  3), 		 // 1294 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  750,  2, 15,  5,  4), 		 // 1329 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  711,  3, 11,  6,  3), 		 // 1664 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  713,  3, 11,  6,  3), 		 // 1668 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  722,  3, 11,  6,  3), 		 // 1688 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  713,  4,  9,  6,  3), 		 // 2047 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  712,  4,  9,  7,  3), 		 // 2066 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  693,  5,  8, 10,  2), 		 // 2446 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  695,  6,  7, 10,  2), 		 // 2822 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  696,  7,  6, 10,  2), 		 // 3196 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  700,  8,  5, 10,  2), 		 // 3586 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  710, 10,  4, 10,  2), 		 // 4391 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  727, 14,  3, 10,  2), 		 // 6039 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 14,  702, 42,  1, 20,  1), 		 // 16496 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_parameters.ref-02-03-2022

@@ -0,0 +1,240 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  538,  2,  8,  3,  3), 		 //   46 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  514,  2,  8,  5,  2), 		 //   46 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  519,  2,  8,  5,  2), 		 //   46 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  515,  3,  6,  5,  2), 		 //   59 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 1, 10,  523,  3,  6,  5,  2), 		 //   60 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.4e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.5e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  564,  1, 23,  3,  3), 		 //   71 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  569,  1, 23,  3,  3), 		 //   72 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  555,  1, 23,  5,  2), 		 //   75 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 4.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 5.5e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  535,  2, 16,  5,  2), 		 //  102 mops, 5.3e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  544,  2, 16,  5,  2), 		 //  103 mops, 5.6e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  533,  3, 12,  5,  2), 		 //  130 mops, 5.0e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  533,  3, 12,  5,  2), 		 //  130 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  536,  3, 12,  5,  2), 		 //  131 mops, 5.6e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  552,  3, 12,  5,  2), 		 //  135 mops, 5.7e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  536,  4,  9,  5,  2), 		 //  160 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  555,  4,  9,  5,  2), 		 //  166 mops, 5.7e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  539,  5,  8,  5,  2), 		 //  191 mops, 5.2e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  593,  5,  8,  5,  2), 		 //  209 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  541,  7,  6,  5,  2), 		 //  251 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  569,  8,  5,  5,  2), 		 //  294 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  549, 11,  4,  5,  2), 		 //  374 mops, 5.5e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  559, 15,  3,  5,  2), 		 //  503 mops, 5.8e-5 errors
+    /* 30 */ V0Parameter( 1, 11,  542, 44,  1, 10,  1), 		 // 1358 mops, 6.0e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  557,  2,  8,  5,  2), 		 //   49 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  564,  2,  8,  5,  2), 		 //   50 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  558,  3,  6,  5,  2), 		 //   63 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  569,  3,  6,  5,  2), 		 //   65 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  579,  1, 23,  5,  2), 		 //   78 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  579,  1, 23,  5,  2), 		 //   78 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  580,  1, 23,  5,  2), 		 //   78 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  581,  1, 23,  5,  2), 		 //   78 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  585,  1, 23,  5,  2), 		 //   78 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  639,  1, 23,  5,  2), 		 //   85 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  580,  2, 16,  5,  2), 		 //  109 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  583,  2, 16,  5,  2), 		 //  110 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  599,  2, 16,  5,  2), 		 //  113 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  580,  3, 12,  5,  2), 		 //  141 mops, 5.2e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  581,  3, 12,  5,  2), 		 //  141 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  585,  3, 12,  5,  2), 		 //  142 mops, 5.7e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  622,  3, 12,  5,  2), 		 //  151 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  585,  4,  9,  5,  2), 		 //  174 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  639,  4,  9,  5,  2), 		 //  190 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  589,  5,  8,  5,  2), 		 //  208 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  591,  6,  7,  5,  2), 		 //  241 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  595,  7,  6,  5,  2), 		 //  275 mops, 5.7e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  627,  8,  5, 11,  2), 		 //  338 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  611, 11,  4,  5,  2), 		 //  416 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  617, 15,  3, 11,  2), 		 //  569 mops, 5.8e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  600, 44,  1, 22,  1), 		 // 1531 mops, 5.8e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  673,  2,  8,  5,  4), 		 //   59 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  641,  3,  6,  5,  2), 		 //   72 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  649,  3,  6,  7,  3), 		 //   76 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  679,  1, 23,  5,  4), 		 //   90 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  679,  1, 23,  5,  4), 		 //   90 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  680,  1, 23,  5,  4), 		 //   90 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  681,  1, 23,  5,  4), 		 //   90 mops, 4.8e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  684,  1, 23,  5,  4), 		 //   90 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  710,  1, 23,  5,  4), 		 //   94 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  680,  2, 16,  5,  4), 		 //  127 mops, 4.8e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  680,  2, 16,  5,  4), 		 //  127 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  682,  2, 16,  5,  4), 		 //  127 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  694,  2, 16,  5,  4), 		 //  130 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  652,  3, 12,  7,  3), 		 //  163 mops, 4.8e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  652,  3, 12,  7,  3), 		 //  163 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  655,  3, 12,  7,  3), 		 //  164 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  675,  3, 12,  7,  3), 		 //  168 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  656,  4,  9,  7,  3), 		 //  200 mops, 5.4e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  679,  4,  9,  7,  3), 		 //  206 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  659,  5,  8,  7,  3), 		 //  237 mops, 5.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  660,  6,  7,  7,  3), 		 //  273 mops, 5.7e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  638,  7,  6, 11,  2), 		 //  309 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  675,  8,  5, 11,  2), 		 //  364 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  647, 11,  4, 11,  2), 		 //  455 mops, 5.7e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  660, 15,  3, 11,  2), 		 //  608 mops, 5.9e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  641, 44,  1, 22,  1), 		 // 1635 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  691,  3,  6,  7,  3), 		 //   80 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  731,  3,  6,  7,  3), 		 //   85 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  721,  1, 23,  5,  4), 		 //   95 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  726,  1, 23,  5,  4), 		 //   95 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  764,  1, 23,  5,  4), 		 //  100 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  721,  2, 16,  5,  4), 		 //  134 mops, 5.3e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  723,  2, 16,  5,  4), 		 //  135 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  738,  2, 16,  5,  4), 		 //  137 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  692,  3, 12,  7,  3), 		 //  172 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  693,  3, 12,  7,  3), 		 //  173 mops, 5.4e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  697,  3, 12,  7,  3), 		 //  174 mops, 5.3e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  724,  3, 12,  7,  3), 		 //  180 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  697,  4,  9,  7,  3), 		 //  212 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  731,  4,  9,  7,  3), 		 //  222 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  700,  5,  8,  7,  3), 		 //  251 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  702,  6,  7,  7,  3), 		 //  290 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  681,  7,  6, 11,  2), 		 //  329 mops, 5.8e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  686,  9,  5, 11,  2), 		 //  407 mops, 5.6e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  692, 11,  4, 11,  2), 		 //  486 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  715, 15,  3, 11,  2), 		 //  658 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  690, 44,  1, 22,  1), 		 // 1760 mops, 6.2e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  776,  1, 23,  5,  4), 		 //  101 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  787,  1, 23,  5,  4), 		 //  103 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  775,  2, 16,  5,  4), 		 //  144 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  781,  2, 16,  5,  4), 		 //  145 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  745,  3, 12,  7,  3), 		 //  185 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  745,  3, 12,  7,  3), 		 //  185 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  747,  3, 12,  7,  3), 		 //  186 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  755,  3, 12,  7,  3), 		 //  187 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  747,  4,  9,  7,  3), 		 //  226 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  756,  4,  9,  7,  3), 		 //  229 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  748,  5,  8,  7,  3), 		 //  268 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  766,  5,  8,  7,  3), 		 //  274 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  773,  6,  7,  7,  3), 		 //  319 mops, 6.0e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  756,  7,  6, 11,  2), 		 //  365 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  729, 11,  4, 11,  2), 		 //  512 mops, 6.0e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  745, 14,  3, 11,  2), 		 //  645 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  746, 22,  2, 11,  2), 		 //  972 mops, 6.2e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  833,  1, 23,  5,  4), 		 //  230 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  833,  1, 23,  5,  4), 		 //  230 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  835,  1, 23,  5,  4), 		 //  231 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  843,  1, 23,  5,  4), 		 //  233 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  834,  2, 15,  5,  4), 		 //  328 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  840,  2, 15,  5,  4), 		 //  331 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  843,  2, 15, 11,  2), 		 //  371 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  804,  3, 12,  7,  3), 		 //  424 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  807,  3, 12,  7,  3), 		 //  425 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  818,  3, 12,  7,  3), 		 //  431 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  806,  4,  9,  7,  3), 		 //  519 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  813,  4,  9,  7,  3), 		 //  524 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  809,  5,  8,  7,  3), 		 //  616 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  839,  5,  8,  7,  3), 		 //  638 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  828,  6,  7, 11,  2), 		 //  753 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  793,  8,  5, 11,  2), 		 //  908 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  791, 11,  4, 11,  2), 		 // 1184 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  805, 14,  3, 11,  2), 		 // 1487 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  821, 22,  2, 11,  2), 		 // 2286 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  1 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  2 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  3 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  4 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  5 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  6 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  7 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  8 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /*  9 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 10 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 11 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 12 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 13 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 14 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 15 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 16 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_parameters.ref-12-05-2022

@@ -0,0 +1,274 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  538,  2,  8,  3,  3), 		 //   46 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  514,  2,  8,  5,  2), 		 //   46 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  519,  2,  8,  5,  2), 		 //   46 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  515,  3,  6,  5,  2), 		 //   59 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 1, 10,  523,  3,  6,  5,  2), 		 //   60 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.4e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.5e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  564,  1, 23,  3,  3), 		 //   71 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  570,  1, 23,  3,  3), 		 //   72 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  560,  1, 23,  5,  2), 		 //   75 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 4.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  536,  2, 16,  5,  2), 		 //  102 mops, 5.5e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  551,  2, 16,  5,  2), 		 //  104 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  533,  3, 12,  5,  2), 		 //  130 mops, 5.1e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  534,  3, 12,  5,  2), 		 //  131 mops, 5.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  538,  3, 12,  5,  2), 		 //  132 mops, 5.4e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  571,  3, 12,  5,  2), 		 //  139 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  537,  4,  9,  5,  2), 		 //  161 mops, 5.6e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  560,  4,  9,  5,  2), 		 //  167 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  542,  5,  8,  5,  2), 		 //  192 mops, 5.8e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  544,  6,  7,  5,  2), 		 //  222 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  547,  7,  6,  5,  2), 		 //  253 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  586,  8,  5,  6,  2), 		 //  305 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  563, 11,  4,  5,  2), 		 //  384 mops, 5.9e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  579, 15,  3, 11,  1), 		 //  535 mops, 6.3e-5 errors
+    /* 30 */ V0Parameter( 1, 11,  556, 44,  1, 11,  1), 		 // 1395 mops, 5.9e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  557,  2,  8,  5,  2), 		 //   49 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  564,  2,  8,  5,  2), 		 //   50 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  558,  3,  6,  5,  2), 		 //   63 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  569,  3,  6,  5,  2), 		 //   65 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  598,  1, 23,  4,  3), 		 //   78 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  598,  1, 23,  4,  3), 		 //   78 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  598,  1, 23,  4,  3), 		 //   78 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  599,  1, 23,  4,  3), 		 //   78 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  603,  1, 23,  4,  3), 		 //   78 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  629,  1, 23,  4,  3), 		 //   81 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  580,  2, 16,  5,  2), 		 //  109 mops, 5.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  581,  2, 16,  5,  2), 		 //  110 mops, 5.2e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  585,  2, 16,  5,  2), 		 //  110 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  618,  2, 16,  4,  3), 		 //  114 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  580,  3, 12,  5,  2), 		 //  141 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  581,  3, 12,  5,  2), 		 //  141 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  588,  3, 12,  5,  2), 		 //  143 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  613,  3, 12,  6,  2), 		 //  151 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  578,  4,  9,  6,  2), 		 //  175 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  602,  4,  9,  6,  2), 		 //  182 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  583,  5,  8,  6,  2), 		 //  208 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  586,  6,  7,  6,  2), 		 //  241 mops, 5.4e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  589,  7,  6,  6,  2), 		 //  274 mops, 5.4e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  595,  9,  5,  6,  2), 		 //  342 mops, 5.8e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  604, 11,  4,  6,  2), 		 //  413 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  597, 21,  2, 12,  1), 		 //  749 mops, 6.0e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  603, 44,  1, 12,  1), 		 // 1515 mops, 6.0e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  630,  2,  8,  4,  3), 		 //   54 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  599,  3,  6,  6,  2), 		 //   69 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  610,  3,  6,  6,  2), 		 //   70 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  638,  1, 23,  4,  3), 		 //   82 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  639,  1, 23,  4,  3), 		 //   82 mops, 4.8e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  639,  1, 23,  4,  3), 		 //   82 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  640,  1, 23,  4,  3), 		 //   83 mops, 5.2e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  644,  1, 23,  4,  3), 		 //   83 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  683,  1, 23,  4,  3), 		 //   88 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  638,  2, 16,  4,  3), 		 //  117 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  638,  2, 16,  4,  3), 		 //  117 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  638,  2, 16,  4,  3), 		 //  117 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  639,  2, 16,  4,  3), 		 //  117 mops, 5.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  639,  2, 16,  4,  3), 		 //  117 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  643,  2, 16,  4,  3), 		 //  118 mops, 5.4e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  665,  2, 16,  4,  3), 		 //  122 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  614,  3, 12,  6,  2), 		 //  151 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  615,  3, 12,  6,  2), 		 //  152 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  620,  3, 12,  6,  2), 		 //  153 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  665,  3, 12,  7,  2), 		 //  166 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  619,  4,  9,  6,  2), 		 //  186 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  654,  4,  9,  6,  2), 		 //  197 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  626,  5,  8,  6,  2), 		 //  223 mops, 5.6e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  629,  6,  7,  6,  2), 		 //  258 mops, 5.6e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  633,  7,  6,  6,  2), 		 //  294 mops, 5.6e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  642,  9,  5,  6,  2), 		 //  369 mops, 5.8e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  652, 11,  4,  7,  2), 		 //  448 mops, 6.1e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  628, 22,  2,  6,  2), 		 //  807 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  656, 44,  1, 13,  1), 		 // 1650 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  662,  3,  6,  6,  2), 		 //   76 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  686,  3,  6,  7,  2), 		 //   80 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  689,  1, 23,  4,  3), 		 //   88 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  689,  1, 23,  4,  3), 		 //   88 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  690,  1, 23,  4,  3), 		 //   88 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  692,  1, 23,  4,  3), 		 //   89 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  700,  1, 23,  4,  3), 		 //   90 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  742,  1, 23,  5,  3), 		 //   97 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  689,  2, 16,  4,  3), 		 //  126 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  689,  2, 16,  4,  3), 		 //  126 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  689,  2, 16,  4,  3), 		 //  126 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  690,  2, 16,  4,  3), 		 //  126 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  691,  2, 16,  4,  3), 		 //  126 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  698,  2, 16,  4,  3), 		 //  127 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  713,  2, 16,  5,  3), 		 //  133 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  665,  3, 12,  6,  2), 		 //  163 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  667,  3, 12,  6,  2), 		 //  164 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  664,  3, 12,  7,  2), 		 //  166 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  658,  4,  9,  7,  2), 		 //  200 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  663,  4,  9,  7,  2), 		 //  202 mops, 5.4e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  710,  4,  9,  7,  2), 		 //  216 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  670,  5,  8,  7,  2), 		 //  240 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  673,  6,  7,  7,  2), 		 //  278 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  678,  7,  6,  7,  2), 		 //  317 mops, 6.1e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  690,  9,  5,  7,  2), 		 //  398 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  724, 11,  4,  7,  2), 		 //  497 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  673, 22,  2,  7,  2), 		 //  867 mops, 5.9e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  734, 45,  1, 16,  1), 		 // 1894 mops, 6.3e-5 errors
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  737,  1, 23,  5,  3), 		 //   97 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  739,  1, 23,  5,  3), 		 //   97 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  751,  1, 23,  5,  3), 		 //   98 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  736,  2, 16,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  736,  2, 16,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  736,  2, 16,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  736,  2, 16,  5,  3), 		 //  137 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  737,  2, 16,  5,  3), 		 //  137 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  738,  2, 16,  5,  3), 		 //  137 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  747,  2, 16,  5,  3), 		 //  139 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  736,  3, 12,  5,  3), 		 //  177 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  737,  3, 12,  5,  3), 		 //  177 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  740,  3, 12,  5,  3), 		 //  178 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  754,  3, 12,  5,  3), 		 //  181 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  716,  4,  9,  7,  2), 		 //  217 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  729,  4,  9,  7,  2), 		 //  221 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  719,  5,  8,  7,  2), 		 //  258 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  750,  5,  8,  8,  2), 		 //  271 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  722,  7,  6,  7,  2), 		 //  338 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  732,  8,  5,  8,  2), 		 //  385 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  725, 11,  4,  8,  2), 		 //  500 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  751, 14,  3,  8,  2), 		 //  641 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  762, 22,  2, 16,  1), 		 // 1008 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  829,  1, 23,  4,  4), 		 //  223 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  830,  1, 23,  4,  4), 		 //  223 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  832,  1, 23,  4,  4), 		 //  224 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  842,  1, 23,  4,  4), 		 //  226 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  807,  2, 15,  5,  3), 		 //  318 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  809,  2, 15,  5,  3), 		 //  319 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  819,  2, 15,  5,  3), 		 //  323 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  807,  3, 12,  5,  3), 		 //  413 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  808,  3, 12,  5,  3), 		 //  413 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  813,  3, 12,  5,  3), 		 //  416 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  795,  3, 12,  8,  2), 		 //  426 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  775,  4,  9,  8,  2), 		 //  506 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  784,  4,  9,  8,  2), 		 //  512 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  780,  5,  8,  8,  2), 		 //  601 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  781,  6,  7,  8,  2), 		 //  693 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  783,  7,  6,  8,  2), 		 //  786 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  793,  8,  5,  8,  2), 		 //  889 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  792, 11,  4,  8,  2), 		 // 1166 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  812, 14,  3,  9,  2), 		 // 1487 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  785, 43,  1, 17,  1), 		 // 4155 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  862,  1, 23,  6,  3), 		 //  517 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  870,  1, 23,  6,  3), 		 //  521 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  861,  2, 15,  6,  3), 		 //  731 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  866,  2, 15,  6,  3), 		 //  735 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  916,  2, 15,  6,  3), 		 //  776 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  861,  3, 11,  6,  3), 		 //  946 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  863,  3, 11,  6,  3), 		 //  949 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  880,  3, 11,  6,  3), 		 //  967 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  862,  4,  9,  6,  3), 		 // 1163 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  870,  4,  9,  6,  3), 		 // 1174 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  842,  5,  8,  9,  2), 		 // 1387 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  844,  6,  7,  9,  2), 		 // 1601 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  846,  7,  6,  9,  2), 		 // 1816 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  853,  8,  5,  9,  2), 		 // 2044 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  897, 10,  4, 10,  2), 		 // 2611 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  881, 14,  3, 10,  2), 		 // 3446 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  849, 43,  1, 18,  1), 		 // 9583 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  936,  2, 15,  6,  3), 		 // 1673 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  958,  2, 15,  5,  4), 		 // 1680 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  958,  2, 15,  7,  3), 		 // 1740 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  935,  3, 11,  6,  3), 		 // 2168 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  925,  3, 11,  7,  3), 		 // 2174 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  936,  3, 11,  7,  3), 		 // 2199 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  924,  4,  9,  7,  3), 		 // 2663 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  932,  4,  9,  7,  3), 		 // 2685 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  905,  5,  8, 10,  2), 		 // 3175 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  908,  6,  7, 10,  2), 		 // 3668 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  910,  7,  6, 10,  2), 		 // 4159 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  916,  8,  5, 10,  2), 		 // 4673 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  946, 10,  4, 10,  2), 		 // 5829 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  908, 21,  2, 10,  2), 		 // 10903 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 14,  932, 42,  1, 21,  1), 		 // 21908 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_parameters.ref-20-06-2022

@@ -0,0 +1,274 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  538,  2,  8,  3,  3), 		 //   46 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  514,  2,  8,  5,  2), 		 //   46 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  519,  2,  8,  5,  2), 		 //   46 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  563,  1, 23,  3,  3), 		 //   55 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  563,  1, 23,  3,  3), 		 //   55 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  563,  1, 23,  3,  3), 		 //   55 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  563,  1, 23,  3,  3), 		 //   55 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  563,  1, 23,  3,  3), 		 //   55 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  564,  1, 23,  3,  3), 		 //   55 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  570,  1, 23,  3,  3), 		 //   56 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  559,  1, 23,  5,  2), 		 //   59 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  563,  2, 16,  3,  3), 		 //   78 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  563,  2, 16,  3,  3), 		 //   78 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  563,  2, 16,  3,  3), 		 //   78 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  563,  2, 16,  3,  3), 		 //   78 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  564,  2, 16,  3,  3), 		 //   79 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  568,  2, 16,  3,  3), 		 //   79 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 //   81 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533,  3, 12,  5,  2), 		 //  101 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  534,  3, 12,  5,  2), 		 //  101 mops, 5.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  538,  3, 12,  5,  2), 		 //  102 mops, 5.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 //  106 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  537,  4,  9,  5,  2), 		 //  123 mops, 5.6e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  559,  4,  9,  5,  2), 		 //  128 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  541,  5,  8,  5,  2), 		 //  146 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  543,  6,  7,  5,  2), 		 //  169 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  546,  7,  6,  5,  2), 		 //  193 mops, 5.9e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  581,  8,  5,  6,  2), 		 //  231 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  559, 11,  4,  5,  2), 		 //  289 mops, 6.3e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  581, 15,  3,  6,  2), 		 //  397 mops, 6.3e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  552, 44,  1, 11,  1), 		 // 1045 mops, 6.2e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  557,  2,  8,  5,  2), 		 //   49 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  564,  2,  8,  5,  2), 		 //   50 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  599,  1, 23,  4,  3), 		 //   61 mops, 4.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  599,  1, 23,  4,  3), 		 //   61 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  599,  1, 23,  4,  3), 		 //   61 mops, 4.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  599,  1, 23,  4,  3), 		 //   61 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  599,  1, 23,  4,  3), 		 //   61 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  600,  1, 23,  4,  3), 		 //   61 mops, 5.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  603,  1, 23,  4,  3), 		 //   61 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  629,  1, 23,  4,  3), 		 //   63 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  580,  2, 16,  5,  2), 		 //   85 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  580,  2, 16,  5,  2), 		 //   85 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  580,  2, 16,  5,  2), 		 //   85 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  580,  2, 16,  5,  2), 		 //   85 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  581,  2, 16,  5,  2), 		 //   85 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  602,  2, 16,  4,  3), 		 //   86 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  618,  2, 16,  4,  3), 		 //   88 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  580,  3, 12,  5,  2), 		 //  109 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  582,  3, 12,  5,  2), 		 //  109 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  588,  3, 12,  5,  2), 		 //  110 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  610,  3, 12,  6,  2), 		 //  117 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  587,  4,  9,  5,  2), 		 //  134 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  602,  4,  9,  6,  2), 		 //  140 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  583,  5,  8,  6,  2), 		 //  160 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  585,  6,  7,  6,  2), 		 //  184 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  588,  7,  6,  6,  2), 		 //  209 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  648,  8,  5,  7,  2), 		 //  259 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  602, 11,  4,  6,  2), 		 //  313 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  627, 15,  3, 13,  1), 		 //  445 mops, 6.3e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  600, 44,  1, 12,  1), 		 // 1138 mops, 6.0e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  630,  2,  8,  4,  3), 		 //   54 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  641,  1, 23,  4,  3), 		 //   64 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  641,  1, 23,  4,  3), 		 //   64 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  641,  1, 23,  4,  3), 		 //   64 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  641,  1, 23,  4,  3), 		 //   64 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  641,  1, 23,  4,  3), 		 //   64 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  642,  1, 23,  4,  3), 		 //   65 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  647,  1, 23,  4,  3), 		 //   65 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  702,  1, 23,  4,  3), 		 //   70 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  641,  2, 16,  4,  3), 		 //   91 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  641,  2, 16,  4,  3), 		 //   91 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  641,  2, 16,  4,  3), 		 //   91 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  641,  2, 16,  4,  3), 		 //   91 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  642,  2, 16,  4,  3), 		 //   91 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  646,  2, 16,  4,  3), 		 //   91 mops, 5.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  669,  2, 16,  4,  3), 		 //   94 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  641,  3, 12,  4,  3), 		 //  117 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  643,  3, 12,  4,  3), 		 //  117 mops, 5.1e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  648,  3, 12,  4,  3), 		 //  118 mops, 5.8e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  674,  3, 12,  7,  2), 		 //  131 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  622,  4,  9,  6,  2), 		 //  144 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  667,  4,  9,  6,  2), 		 //  154 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  629,  5,  8,  6,  2), 		 //  172 mops, 5.6e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  632,  6,  7,  6,  2), 		 //  198 mops, 5.8e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  636,  7,  6,  6,  2), 		 //  226 mops, 6.0e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  646,  9,  5,  6,  2), 		 //  282 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  657, 11,  4,  7,  2), 		 //  343 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  632, 22,  2,  6,  2), 		 //  613 mops, 5.5e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  649, 45,  1, 13,  1), 		 // 1259 mops, 6.3e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  750,  1, 23,  3,  4), 		 //   71 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  750,  1, 23,  3,  4), 		 //   71 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  750,  1, 23,  3,  4), 		 //   71 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  750,  1, 23,  3,  4), 		 //   71 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  752,  1, 23,  3,  4), 		 //   71 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  726,  1, 23,  4,  3), 		 //   72 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  708,  1, 23,  5,  3), 		 //   73 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  696,  2, 16,  5,  3), 		 //  101 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  696,  2, 16,  5,  3), 		 //  101 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  696,  2, 16,  5,  3), 		 //  101 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  696,  2, 16,  5,  3), 		 //  101 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  697,  2, 16,  5,  3), 		 //  101 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  698,  2, 16,  5,  3), 		 //  101 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  704,  2, 16,  5,  3), 		 //  102 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  696,  3, 12,  5,  3), 		 //  129 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  697,  3, 12,  5,  3), 		 //  129 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  699,  3, 12,  5,  3), 		 //  130 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  710,  3, 12,  5,  3), 		 //  132 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  672,  4,  9,  7,  2), 		 //  158 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  681,  4,  9,  7,  2), 		 //  160 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  674,  5,  8,  7,  2), 		 //  186 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  697,  5,  8,  7,  2), 		 //  192 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  710,  6,  7,  7,  2), 		 //  225 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  686,  8,  5,  7,  2), 		 //  273 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  681, 11,  4,  7,  2), 		 //  355 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  699, 14,  3,  7,  2), 		 //  451 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  709, 22,  2,  7,  2), 		 //  690 mops, 6.2e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  736,  1, 23,  5,  3), 		 //   97 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  737,  1, 23,  5,  3), 		 //   97 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  739,  1, 23,  5,  3), 		 //   97 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  752,  1, 23,  5,  3), 		 //   99 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  736,  2, 15,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  736,  2, 15,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  736,  2, 15,  5,  3), 		 //  137 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  736,  2, 15,  5,  3), 		 //  137 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  737,  2, 15,  5,  3), 		 //  137 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  739,  2, 15,  5,  3), 		 //  137 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  748,  2, 15,  5,  3), 		 //  139 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  736,  3, 12,  5,  3), 		 //  177 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  737,  3, 12,  5,  3), 		 //  177 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  740,  3, 12,  5,  3), 		 //  178 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  759,  3, 12,  5,  3), 		 //  182 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  716,  4,  9,  7,  2), 		 //  217 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  730,  4,  9,  7,  2), 		 //  221 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  720,  5,  8,  7,  2), 		 //  258 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  722,  6,  7,  7,  2), 		 //  298 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  724,  7,  6,  7,  2), 		 //  338 mops, 6.0e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  735,  8,  5,  8,  2), 		 //  387 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  728, 11,  4,  8,  2), 		 //  502 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  773, 14,  3,  8,  2), 		 //  660 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  732, 43,  1, 15,  1), 		 // 1806 mops, 6.2e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  829,  1, 23,  4,  4), 		 //  223 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  830,  1, 23,  4,  4), 		 //  223 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  832,  1, 23,  4,  4), 		 //  224 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  846,  1, 23,  4,  4), 		 //  227 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  806,  2, 15,  5,  3), 		 //  318 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  807,  2, 15,  5,  3), 		 //  318 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  807,  2, 15,  5,  3), 		 //  318 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  809,  2, 15,  5,  3), 		 //  319 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  821,  2, 15,  5,  3), 		 //  323 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  807,  3, 12,  5,  3), 		 //  413 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  808,  3, 12,  5,  3), 		 //  413 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  815,  3, 12,  5,  3), 		 //  417 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  836,  3, 12,  6,  3), 		 //  434 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  776,  4,  9,  8,  2), 		 //  507 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  786,  4,  9,  8,  2), 		 //  513 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  782,  5,  8,  8,  2), 		 //  602 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  785,  6,  7,  8,  2), 		 //  696 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  788,  7,  6,  8,  2), 		 //  791 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  801,  8,  5,  8,  2), 		 //  898 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  804, 11,  4,  8,  2), 		 // 1184 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  843, 15,  3,  9,  2), 		 // 1642 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  798, 43,  1, 17,  1), 		 // 4224 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  863,  1, 23,  6,  3), 		 //  517 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  874,  1, 23,  6,  3), 		 //  523 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  860,  2, 15,  6,  3), 		 //  730 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  861,  2, 15,  6,  3), 		 //  731 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  868,  2, 15,  6,  3), 		 //  737 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  860,  3, 11,  6,  3), 		 //  945 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  861,  3, 11,  6,  3), 		 //  946 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  864,  3, 11,  6,  3), 		 //  950 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  886,  3, 11,  6,  3), 		 //  973 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  863,  4,  9,  6,  3), 		 // 1164 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  874,  4,  9,  6,  3), 		 // 1179 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  847,  5,  8,  9,  2), 		 // 1395 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  851,  6,  7,  9,  2), 		 // 1614 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  855,  7,  6,  9,  2), 		 // 1835 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  869,  8,  5,  9,  2), 		 // 2082 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  892, 11,  4, 10,  2), 		 // 2819 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  852, 21,  2,  9,  2), 		 // 4811 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  879, 44,  1, 19,  1), 		 // 10154 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  934,  2, 15,  6,  3), 		 // 1669 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  954,  2, 15,  5,  4), 		 // 1674 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  962,  2, 15,  5,  4), 		 // 1687 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  934,  3, 11,  6,  3), 		 // 2165 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  935,  3, 11,  6,  3), 		 // 2168 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  926,  3, 11,  7,  3), 		 // 2176 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  943,  3, 11,  7,  3), 		 // 2215 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  926,  4,  9,  7,  3), 		 // 2668 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  940,  4,  9,  7,  3), 		 // 2708 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  915,  5,  8, 10,  2), 		 // 3209 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  921,  6,  7, 10,  2), 		 // 3719 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  931,  7,  6, 10,  2), 		 // 4253 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  943,  8,  5, 21,  1), 		 // 5133 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  908, 14,  3, 10,  2), 		 // 7527 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  919, 21,  2, 10,  2), 		 // 11035 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_parameters.ref-23-03-2022

@@ -0,0 +1,274 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  538,  2,  8,  3,  3), 		 //   46 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  514,  2,  8,  5,  2), 		 //   46 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  519,  2,  8,  5,  2), 		 //   46 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  515,  3,  6,  5,  2), 		 //   59 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 1, 10,  523,  3,  6,  5,  2), 		 //   60 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.4e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.5e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  563,  1, 23,  3,  3), 		 //   71 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  564,  1, 23,  3,  3), 		 //   71 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  570,  1, 23,  3,  3), 		 //   72 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  560,  1, 23,  5,  2), 		 //   75 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  532,  2, 16,  5,  2), 		 //  101 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 4.9e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  533,  2, 16,  5,  2), 		 //  101 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  536,  2, 16,  5,  2), 		 //  102 mops, 5.5e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  551,  2, 16,  5,  2), 		 //  104 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  533,  3, 12,  5,  2), 		 //  130 mops, 5.1e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  534,  3, 12,  5,  2), 		 //  131 mops, 5.0e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  538,  3, 12,  5,  2), 		 //  132 mops, 5.4e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  571,  3, 12,  5,  2), 		 //  139 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  537,  4,  9,  5,  2), 		 //  161 mops, 5.6e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  560,  4,  9,  5,  2), 		 //  167 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  542,  5,  8,  5,  2), 		 //  192 mops, 5.8e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  544,  6,  7,  5,  2), 		 //  222 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  547,  7,  6,  5,  2), 		 //  253 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  553,  9,  5,  5,  2), 		 //  316 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  563, 11,  4,  5,  2), 		 //  384 mops, 5.9e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  620, 15,  3, 11,  2), 		 //  572 mops, 6.3e-5 errors
+    /* 30 */ V0Parameter( 1, 11,  560, 44,  1, 10,  1), 		 // 1403 mops, 6.3e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  557,  2,  8,  5,  2), 		 //   49 mops, 5.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  564,  2,  8,  5,  2), 		 //   50 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  558,  3,  6,  5,  2), 		 //   63 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 1, 10,  569,  3,  6,  5,  2), 		 //   65 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  579,  1, 23,  5,  2), 		 //   78 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  579,  1, 23,  5,  2), 		 //   78 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  580,  1, 23,  5,  2), 		 //   78 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  581,  1, 23,  5,  2), 		 //   78 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  586,  1, 23,  5,  2), 		 //   78 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  675,  1, 23,  5,  4), 		 //   89 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  579,  2, 16,  5,  2), 		 //  109 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  580,  2, 16,  5,  2), 		 //  109 mops, 5.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  581,  2, 16,  5,  2), 		 //  110 mops, 5.2e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  585,  2, 16,  5,  2), 		 //  110 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  620,  2, 16,  5,  2), 		 //  117 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  580,  3, 12,  5,  2), 		 //  141 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  581,  3, 12,  5,  2), 		 //  141 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  588,  3, 12,  5,  2), 		 //  143 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  657,  3, 12,  7,  3), 		 //  164 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  586,  4,  9,  5,  2), 		 //  175 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  644,  4,  9,  7,  3), 		 //  196 mops, 5.9e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  596,  5,  8,  5,  2), 		 //  210 mops, 5.8e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  600,  6,  7,  5,  2), 		 //  244 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  607,  7,  6,  5,  2), 		 //  280 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  630,  9,  5,  5,  2), 		 //  359 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  621, 11,  4, 11,  2), 		 //  437 mops, 5.9e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  588, 22,  2, 10,  1), 		 //  766 mops, 6.0e-5 errors
+    /* 29 */ V0Parameter( 1, 11,  619, 44,  1, 22,  1), 		 // 1579 mops, 6.2e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  673,  2,  8,  5,  4), 		 //   59 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  641,  3,  6,  5,  2), 		 //   72 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  649,  3,  6,  7,  3), 		 //   76 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  679,  1, 23,  5,  4), 		 //   90 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  680,  1, 23,  5,  4), 		 //   90 mops, 4.7e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  680,  1, 23,  5,  4), 		 //   90 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  681,  1, 23,  5,  4), 		 //   90 mops, 5.0e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  685,  1, 23,  5,  4), 		 //   90 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  679,  2, 16,  5,  4), 		 //  127 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  680,  2, 16,  5,  4), 		 //  127 mops, 4.9e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  680,  2, 16,  5,  4), 		 //  127 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  684,  2, 16,  5,  4), 		 //  128 mops, 5.2e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  704,  2, 16,  5,  4), 		 //  131 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  652,  3, 12,  7,  3), 		 //  163 mops, 4.9e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  653,  3, 12,  7,  3), 		 //  163 mops, 5.1e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  658,  3, 12,  7,  3), 		 //  164 mops, 5.1e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  712,  3, 12,  7,  3), 		 //  177 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  657,  4,  9,  7,  3), 		 //  200 mops, 5.1e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  688,  4,  9,  7,  3), 		 //  209 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  663,  5,  8,  7,  3), 		 //  238 mops, 5.4e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  665,  6,  7,  7,  3), 		 //  275 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  645,  7,  6, 11,  2), 		 //  312 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  653,  9,  5, 11,  2), 		 //  388 mops, 5.7e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  665, 11,  4, 11,  2), 		 //  467 mops, 6.3e-5 errors
+    /* 27 */ V0Parameter( 1, 11,  641, 22,  2, 11,  2), 		 //  836 mops, 6.1e-5 errors
+    /* 28 */ V0Parameter( 1, 11,  670, 44,  1, 22,  1), 		 // 1709 mops, 6.2e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 1, 10,  691,  3,  6,  7,  3), 		 //   80 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  731,  3,  6,  7,  3), 		 //   85 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  720,  1, 23,  5,  4), 		 //   95 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  721,  1, 23,  5,  4), 		 //   95 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  727,  1, 23,  5,  4), 		 //   96 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  754,  1, 23,  7,  3), 		 //  105 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  720,  2, 16,  5,  4), 		 //  134 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  721,  2, 16,  5,  4), 		 //  134 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  725,  2, 16,  5,  4), 		 //  135 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  754,  2, 16,  5,  4), 		 //  140 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  692,  3, 12,  7,  3), 		 //  172 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  693,  3, 12,  7,  3), 		 //  173 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  699,  3, 12,  7,  3), 		 //  174 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  693,  4,  9,  7,  3), 		 //  211 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  698,  4,  9,  7,  3), 		 //  212 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  754,  4,  9,  7,  3), 		 //  228 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  706,  5,  8,  7,  3), 		 //  253 mops, 5.6e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  709,  6,  7,  7,  3), 		 //  293 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  690,  7,  6, 11,  2), 		 //  334 mops, 5.9e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  701,  9,  5, 11,  2), 		 //  416 mops, 6.3e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  733, 11,  4, 11,  2), 		 //  514 mops, 6.3e-5 errors
+    /* 26 */ V0Parameter( 1, 11,  685, 22,  2, 11,  2), 		 //  893 mops, 5.7e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  774,  1, 23,  5,  4), 		 //  101 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  777,  1, 23,  5,  4), 		 //  102 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  789,  1, 23,  5,  4), 		 //  103 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  774,  2, 16,  5,  4), 		 //  144 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  776,  2, 16,  5,  4), 		 //  144 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  785,  2, 16,  5,  4), 		 //  146 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  745,  3, 12,  7,  3), 		 //  185 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  745,  3, 12,  7,  3), 		 //  185 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  748,  3, 12,  7,  3), 		 //  186 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  762,  3, 12,  7,  3), 		 //  189 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  747,  4,  9,  7,  3), 		 //  226 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  759,  4,  9,  7,  3), 		 //  230 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  750,  5,  8,  7,  3), 		 //  268 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  794,  5,  8,  7,  3), 		 //  284 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  728,  7,  6, 11,  2), 		 //  352 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  741,  8,  5, 11,  2), 		 //  398 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  734, 11,  4, 11,  2), 		 //  515 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  762, 14,  3, 11,  2), 		 //  659 mops, 6.2e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  766, 23,  2, 22,  1), 		 // 1073 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  833,  1, 23,  5,  4), 		 //  230 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  833,  1, 23,  5,  4), 		 //  230 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  835,  1, 23,  5,  4), 		 //  231 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  844,  1, 23,  5,  4), 		 //  233 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  833,  2, 15,  5,  4), 		 //  328 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  835,  2, 15,  5,  4), 		 //  329 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  841,  2, 15,  5,  4), 		 //  331 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  804,  3, 12,  7,  3), 		 //  424 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  804,  3, 12,  7,  3), 		 //  424 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  807,  3, 12,  7,  3), 		 //  425 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  825,  3, 12,  7,  3), 		 //  435 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  806,  4,  9,  7,  3), 		 //  519 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  814,  4,  9,  7,  3), 		 //  524 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  810,  5,  8,  7,  3), 		 //  617 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  812,  6,  7,  7,  3), 		 //  713 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  814,  7,  6,  7,  3), 		 //  811 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  797,  8,  5, 11,  2), 		 //  912 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  796, 11,  4, 11,  2), 		 // 1191 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  818, 14,  3, 11,  2), 		 // 1511 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  804, 43,  1, 11,  2), 		 // 4218 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  894,  1, 23,  5,  4), 		 //  521 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  903,  1, 23,  5,  4), 		 //  525 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  892,  2, 15,  5,  4), 		 //  742 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  892,  2, 15,  5,  4), 		 //  742 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  892,  2, 15,  5,  4), 		 //  742 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  892,  2, 15,  5,  4), 		 //  742 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  893,  2, 15,  5,  4), 		 //  743 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  894,  2, 15,  5,  4), 		 //  744 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  898,  2, 15,  5,  4), 		 //  747 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  909,  2, 15,  7,  3), 		 //  784 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  864,  3, 12,  7,  3), 		 //  963 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  867,  3, 12,  7,  3), 		 //  966 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  891,  3, 12,  7,  3), 		 //  992 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  865,  4,  9,  7,  3), 		 // 1180 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  872,  4,  9,  7,  3), 		 // 1190 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  871,  5,  8,  7,  3), 		 // 1406 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  873,  6,  7,  7,  3), 		 // 1628 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  875,  7,  6,  7,  3), 		 // 1850 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  856,  8,  5, 11,  2), 		 // 2078 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  902, 10,  4, 11,  2), 		 // 2639 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  884, 14,  3, 11,  2), 		 // 3471 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 13,  865, 43,  1, 11,  2), 		 // 9668 mops, 6.1e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  952,  2, 15,  5,  4), 		 // 1670 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  952,  2, 15,  5,  4), 		 // 1670 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  952,  2, 15,  5,  4), 		 // 1670 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  952,  2, 15,  5,  4), 		 // 1670 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  953,  2, 15,  5,  4), 		 // 1672 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  954,  2, 15,  5,  4), 		 // 1674 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  958,  2, 15,  5,  4), 		 // 1680 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  958,  2, 15,  7,  3), 		 // 1740 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  924,  3, 12,  7,  3), 		 // 2172 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  928,  3, 12,  7,  3), 		 // 2181 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  964,  3, 12,  7,  3), 		 // 2263 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  924,  4,  9,  7,  3), 		 // 2663 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  932,  4,  9,  7,  3), 		 // 2685 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  932,  5,  8,  7,  3), 		 // 3180 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  935,  6,  7,  7,  3), 		 // 3687 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  912,  7,  6, 11,  2), 		 // 4197 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  917,  8,  5, 11,  2), 		 // 4706 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  944, 10,  4, 11,  2), 		 // 5846 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  910, 21,  2, 11,  2), 		 // 10956 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 1, 14,  916, 43,  1, 22,  1), 		 // 22049 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/v0_parameters.ref-24-06-2022

@@ -0,0 +1,274 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 1, 10,  556,  2,  8,  3,  3), 		 //   47 mops, 5.3e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  558,  2,  8,  3,  3), 		 //   47 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 10,  543,  2,  8,  5,  2), 		 //   48 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  580,  1, 23,  3,  3), 		 //   57 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  582,  1, 23,  3,  3), 		 //   57 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  1, 23,  3,  3), 		 //   57 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  603,  1, 23,  4,  3), 		 //   61 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  580,  2, 16,  3,  3), 		 //   81 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  581,  2, 16,  3,  3), 		 //   81 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  585,  2, 16,  3,  3), 		 //   81 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  568,  2, 16,  5,  2), 		 //   84 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  550,  3, 12,  5,  2), 		 //  104 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551,  3, 12,  5,  2), 		 //  104 mops, 5.5e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  555,  3, 12,  5,  2), 		 //  105 mops, 5.6e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  586,  3, 12,  5,  2), 		 //  110 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  554,  4,  9,  5,  2), 		 //  127 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  578,  4,  9,  5,  2), 		 //  132 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  559,  5,  8,  5,  2), 		 //  151 mops, 5.8e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  561,  6,  7,  5,  2), 		 //  175 mops, 6.0e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  564,  7,  6,  5,  2), 		 //  199 mops, 5.8e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  604,  8,  5,  6,  2), 		 //  239 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  578, 11,  4,  5,  2), 		 //  298 mops, 6.2e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  604, 15,  3,  6,  2), 		 //  413 mops, 6.2e-5 errors
+    /* 30 */ V0Parameter( 2, 10,  572, 44,  1, 11,  1), 		 // 1083 mops, 5.8e-5 errors
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 1, 10,  575,  2,  8,  5,  2), 		 //   51 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 10,  591,  2,  8,  5,  2), 		 //   52 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  616,  1, 23,  4,  3), 		 //   62 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  617,  1, 23,  4,  3), 		 //   62 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  621,  1, 23,  4,  3), 		 //   63 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  648,  1, 23,  4,  3), 		 //   65 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  597,  2, 16,  5,  2), 		 //   87 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  598,  2, 16,  5,  2), 		 //   88 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  619,  2, 16,  4,  3), 		 //   88 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  636,  2, 16,  4,  3), 		 //   90 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  598,  3, 12,  5,  2), 		 //  112 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  599,  3, 12,  5,  2), 		 //  112 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  606,  3, 12,  5,  2), 		 //  113 mops, 5.7e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  630,  3, 12,  6,  2), 		 //  120 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  605,  4,  9,  5,  2), 		 //  138 mops, 5.6e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  621,  4,  9,  6,  2), 		 //  144 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  601,  5,  8,  6,  2), 		 //  164 mops, 5.6e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  603,  6,  7,  6,  2), 		 //  189 mops, 5.9e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  606,  7,  6,  6,  2), 		 //  215 mops, 5.8e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  612,  9,  5,  6,  2), 		 //  268 mops, 6.0e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  621, 11,  4,  6,  2), 		 //  322 mops, 6.2e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  629, 21,  2,  6,  2), 		 //  584 mops, 6.1e-5 errors
+    /* 29 */ V0Parameter( 2, 10,  620, 44,  1, 12,  1), 		 // 1176 mops, 6.1e-5 errors
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 1, 10,  658,  2,  8,  4,  3), 		 //   56 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  688,  1, 23,  3,  4), 		 //   66 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  689,  1, 23,  3,  4), 		 //   66 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  695,  1, 23,  3,  4), 		 //   67 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  736,  1, 23,  4,  3), 		 //   73 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  658,  2, 16,  4,  3), 		 //   93 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  659,  2, 16,  4,  3), 		 //   93 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  663,  2, 16,  4,  3), 		 //   94 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  688,  2, 16,  4,  3), 		 //   97 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  659,  3, 12,  4,  3), 		 //  120 mops, 5.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  660,  3, 12,  4,  3), 		 //  120 mops, 5.4e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  666,  3, 12,  4,  3), 		 //  121 mops, 5.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  702,  3, 12,  7,  2), 		 //  136 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  640,  4,  9,  6,  2), 		 //  148 mops, 5.4e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  677,  4,  9,  7,  2), 		 //  159 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  646,  5,  8,  6,  2), 		 //  176 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  650,  6,  7,  6,  2), 		 //  204 mops, 5.7e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  654,  7,  6,  6,  2), 		 //  232 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  665,  9,  5,  6,  2), 		 //  290 mops, 6.1e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  677, 11,  4,  7,  2), 		 //  353 mops, 6.2e-5 errors
+    /* 27 */ V0Parameter( 2, 10,  649, 22,  2,  6,  2), 		 //  629 mops, 6.3e-5 errors
+    /* 28 */ V0Parameter( 2, 10,  672, 45,  1, 13,  1), 		 // 1304 mops, 6.1e-5 errors
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  769,  1, 23,  3,  4), 		 //   73 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  771,  1, 23,  3,  4), 		 //   73 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  745,  1, 23,  4,  3), 		 //   74 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  792,  1, 23,  3,  5), 		 //   75 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  714,  2, 16,  5,  3), 		 //  103 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  716,  2, 16,  5,  3), 		 //  103 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  723,  2, 16,  5,  3), 		 //  104 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  714,  3, 12,  5,  3), 		 //  132 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  714,  3, 12,  5,  3), 		 //  132 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  717,  3, 12,  5,  3), 		 //  133 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  728,  3, 12,  5,  3), 		 //  135 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  690,  4,  9,  7,  2), 		 //  162 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  699,  4,  9,  7,  2), 		 //  164 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  692,  5,  8,  7,  2), 		 //  191 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  718,  5,  8,  7,  2), 		 //  198 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  735,  6,  7,  7,  2), 		 //  232 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  705,  8,  5,  7,  2), 		 //  281 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  699, 11,  4,  7,  2), 		 //  365 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 2, 10,  720, 14,  3,  7,  2), 		 //  464 mops, 6.2e-5 errors
+    /* 26 */ V0Parameter( 2, 10,  733, 22,  2,  7,  2), 		 //  713 mops, 6.2e-5 errors
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 1, 11,  754,  1, 23,  5,  3), 		 //   99 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 1, 11,  755,  1, 23,  5,  3), 		 //   99 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 1, 11,  757,  1, 23,  5,  3), 		 //   99 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 1, 11,  771,  1, 23,  5,  3), 		 //  101 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 11,  754,  2, 15,  5,  3), 		 //  140 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 11,  756,  2, 15,  5,  3), 		 //  140 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 1, 11,  766,  2, 15,  5,  3), 		 //  142 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  754,  3, 12,  5,  3), 		 //  181 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  755,  3, 12,  5,  3), 		 //  182 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 1, 11,  758,  3, 12,  5,  3), 		 //  182 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  779,  3, 12,  5,  3), 		 //  187 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 11,  734,  4,  9,  7,  2), 		 //  223 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  749,  4,  9,  7,  2), 		 //  227 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 11,  738,  5,  8,  7,  2), 		 //  264 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 11,  740,  6,  7,  7,  2), 		 //  305 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 1, 11,  742,  7,  6,  7,  2), 		 //  347 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 1, 11,  754,  8,  5,  8,  2), 		 //  396 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 1, 11,  747, 11,  4,  8,  2), 		 //  515 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 1, 11,  760, 15,  3,  8,  2), 		 //  690 mops, 6.1e-5 errors
+    /* 25 */ V0Parameter( 1, 11,  752, 43,  1, 16,  1), 		 // 1858 mops, 6.3e-5 errors
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 1, 12,  847,  1, 23,  4,  4), 		 //  227 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 1, 12,  848,  1, 23,  4,  4), 		 //  228 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 1, 12,  850,  1, 23,  4,  4), 		 //  228 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 12,  864,  1, 23,  4,  4), 		 //  232 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 1, 12,  824,  2, 15,  5,  3), 		 //  325 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 12,  825,  2, 15,  5,  3), 		 //  325 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 12,  827,  2, 15,  5,  3), 		 //  326 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 1, 12,  858,  2, 15,  4,  4), 		 //  331 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 1, 12,  825,  3, 12,  5,  3), 		 //  422 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 12,  826,  3, 12,  5,  3), 		 //  422 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 12,  796,  3, 12,  8,  2), 		 //  426 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 12,  858,  3, 12,  6,  3), 		 //  445 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 12,  793,  4,  9,  8,  2), 		 //  517 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 12,  805,  4,  9,  8,  2), 		 //  525 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 12,  801,  5,  8,  8,  2), 		 //  616 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 1, 12,  803,  6,  7,  8,  2), 		 //  712 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 12,  806,  7,  6,  8,  2), 		 //  809 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 1, 12,  821,  8,  5,  8,  2), 		 //  920 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 1, 12,  820, 11,  4,  9,  2), 		 // 1214 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 1, 12,  809, 21,  2,  8,  2), 		 // 2139 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 1, 12,  821, 43,  1, 17,  1), 		 // 4345 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 1, 13,  880,  1, 23,  6,  3), 		 //  527 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 1, 13,  893,  1, 23,  6,  3), 		 //  534 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 1, 13,  877,  2, 15,  6,  3), 		 //  744 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 1, 13,  878,  2, 15,  6,  3), 		 //  745 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 1, 13,  879,  2, 15,  6,  3), 		 //  746 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 1, 13,  886,  2, 15,  6,  3), 		 //  752 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 1, 13,  878,  3, 11,  6,  3), 		 //  965 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 1, 13,  878,  3, 11,  6,  3), 		 //  965 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 1, 13,  882,  3, 11,  6,  3), 		 //  969 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 1, 13,  906,  3, 11,  6,  3), 		 //  994 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 1, 13,  880,  4,  9,  6,  3), 		 // 1187 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 1, 13,  893,  4,  9,  6,  3), 		 // 1204 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 1, 13,  866,  5,  8,  9,  2), 		 // 1425 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 1, 13,  870,  6,  7,  9,  2), 		 // 1649 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 1, 13,  875,  7,  6,  9,  2), 		 // 1877 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 1, 13,  891,  8,  5,  9,  2), 		 // 2134 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 1, 13,  906, 11,  4, 20,  1), 		 // 3005 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 1, 13,  871, 21,  2,  9,  2), 		 // 4917 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 1, 14,  952,  2, 15,  6,  3), 		 // 1700 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 1, 14,  953,  2, 15,  6,  3), 		 // 1702 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 1, 14,  972,  2, 15,  5,  4), 		 // 1704 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 1, 14,  980,  2, 15,  5,  4), 		 // 1717 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 1, 14,  952,  3, 11,  6,  3), 		 // 2206 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 1, 14,  954,  3, 11,  6,  3), 		 // 2210 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 1, 14,  944,  3, 11,  7,  3), 		 // 2217 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 1, 14,  962,  3, 11,  7,  3), 		 // 2258 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 1, 14,  943,  4,  9,  7,  3), 		 // 2716 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 1, 14,  959,  4,  9,  7,  3), 		 // 2761 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 1, 14,  934,  5,  8, 10,  2), 		 // 3275 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 1, 14,  941,  6,  7, 10,  2), 		 // 3799 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 1, 14,  953,  7,  6, 10,  2), 		 // 4352 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 1, 14,  924, 10,  4, 10,  2), 		 // 5695 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 1, 14,  926, 14,  3, 10,  2), 		 // 7675 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 1, 14,  939, 21,  2, 10,  2), 		 // 11273 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_parameters.ref-15-06-2022

@@ -0,0 +1,546 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  498,  1, 24,  4,  2), 		 //  128 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  502,  1, 24,  4,  2), 		 //  129 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  510,  1, 24,  5,  2), 		 //  132 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  511,  1, 24,  5,  2), 		 //  194 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  537,  1, 24,  5,  2), 		 //  264 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 //  322 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  498,  2, 16,  4,  2), 		 //  322 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  499,  2, 16,  4,  2), 		 //  323 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 //  325 mops, 5.0e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 //  340 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 //  458 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 //  474 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 //  609 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  537,  3, 12,  5,  2), 		 //  787 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  504,  3, 12,  9,  1), 		 //  919 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 1167 mops, 5.4e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 1219 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 1520 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 1980 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 2298 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 2952 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 4228 mops, 5.8e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 6654 mops, 6.2e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 10953 mops, 6.3e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 17307 mops, 6.2e-5 errors
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  508,  1, 24,  4,  2), 		 //  298 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  500,  1, 24,  5,  2), 		 //  420 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  506,  1, 24,  5,  2), 		 //  545 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 //  701 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 //  701 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 //  702 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 //  703 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  506,  2, 16,  5,  2), 		 //  713 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 //  931 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  506,  3, 12,  5,  2), 		 // 1002 mops, 5.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  485,  3, 12,  9,  1), 		 // 1288 mops, 5.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  502,  3, 12,  9,  1), 		 // 1313 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 1886 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  483,  4, 10,  9,  1), 		 // 2419 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  495,  4, 10,  9,  1), 		 // 2451 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  498,  5,  8,  9,  1), 		 // 3012 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  501,  5,  8,  9,  1), 		 // 3500 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  505,  6,  7, 10,  1), 		 // 4165 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522,  7,  6, 10,  1), 		 // 4895 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  507, 11,  4, 10,  1), 		 // 7415 mops, 5.7e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  498, 11,  4, 10,  1), 		 // 10379 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  539, 15,  3, 11,  1), 		 // 14581 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  500, 22,  2, 10,  1), 		 // 32369 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  534, 45,  1, 11,  1), 		 // 71892 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  510,  1, 24,  5,  2), 		 //  606 mops, 5.5e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  1, 24,  5,  2), 		 //  852 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  537,  1, 24,  5,  2), 		 // 1134 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 1403 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 1404 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 1405 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 // 1414 mops, 5.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 // 1486 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 1986 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 // 2061 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 2589 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 3317 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  502,  3, 12, 10,  1), 		 // 3835 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 4860 mops, 5.4e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 5084 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 6339 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 8196 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 9510 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 12213 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 17325 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 27272 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 44460 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 70283 mops, 6.2e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  531,  1, 24,  5,  2), 		 // 1351 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 2161 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 2161 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 2162 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 // 2167 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  2, 16,  5,  2), 		 // 2186 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  505,  2, 16,  5,  2), 		 // 2828 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  502,  3, 12,  5,  2), 		 // 3071 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  483,  3, 12,  9,  1), 		 // 3932 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  495,  3, 12,  9,  1), 		 // 3987 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  3, 12,  9,  1), 		 // 5723 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  491,  4, 10,  9,  1), 		 // 7418 mops, 5.4e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 9108 mops, 5.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  5,  8,  9,  1), 		 // 10542 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  496,  6,  7, 10,  1), 		 // 12520 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  504,  7,  6, 10,  1), 		 // 14584 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  546,  9,  5, 11,  1), 		 // 19302 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  493, 11,  4,  9,  1), 		 // 31210 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  509, 15,  3, 10,  1), 		 // 42829 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  519, 15,  3, 10,  1), 		 // 68314 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  532, 45,  1, 10,  1), 		 // 203790 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  531,  1, 24,  5,  2), 		 // 1351 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 2161 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 2161 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 2162 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 // 2167 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  2, 16,  5,  2), 		 // 2186 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  505,  2, 16,  5,  2), 		 // 2828 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  502,  3, 12,  5,  2), 		 // 3071 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  483,  3, 12,  9,  1), 		 // 3932 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  495,  3, 12,  9,  1), 		 // 3987 mops, 5.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  3, 12,  9,  1), 		 // 5723 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  491,  4, 10,  9,  1), 		 // 7418 mops, 5.4e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 9108 mops, 5.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  5,  8,  9,  1), 		 // 10542 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  496,  6,  7, 10,  1), 		 // 12520 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  504,  7,  6, 10,  1), 		 // 14584 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  546,  9,  5, 11,  1), 		 // 19302 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  493, 11,  4,  9,  1), 		 // 31210 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  509, 15,  3, 10,  1), 		 // 42829 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  519, 15,  3, 10,  1), 		 // 68314 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  532, 45,  1, 10,  1), 		 // 203790 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  508,  1, 24,  5,  2), 		 // 2518 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 3255 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 3307 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  516,  2, 16,  5,  2), 		 // 4297 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  508,  3, 12,  5,  2), 		 // 4639 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  485,  3, 12,  9,  1), 		 // 5912 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 6058 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  491,  3, 12,  9,  1), 		 // 8623 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  484,  4, 10,  9,  1), 		 // 11043 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  498,  4, 10,  9,  1), 		 // 11213 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  501,  5,  8,  9,  1), 		 // 13779 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  5,  8,  9,  1), 		 // 15997 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  510,  6,  7, 10,  1), 		 // 19055 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  544,  7,  6, 11,  1), 		 // 22791 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  512, 11,  4, 10,  1), 		 // 33904 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 11,  4, 10,  1), 		 // 47207 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  524, 11,  4, 10,  1), 		 // 76229 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  504, 22,  2, 10,  1), 		 // 146924 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  545, 46,  1, 11,  1), 		 // 335538 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  508,  1, 24,  5,  2), 		 // 2518 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 3255 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 3307 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  516,  2, 16,  5,  2), 		 // 4297 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  508,  3, 12,  5,  2), 		 // 4639 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  485,  3, 12,  9,  1), 		 // 5912 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 6058 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  491,  3, 12,  9,  1), 		 // 8623 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  484,  4, 10,  9,  1), 		 // 11043 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  498,  4, 10,  9,  1), 		 // 11213 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  501,  5,  8,  9,  1), 		 // 13779 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  5,  8,  9,  1), 		 // 15997 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  510,  6,  7, 10,  1), 		 // 19055 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  544,  7,  6, 11,  1), 		 // 22791 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  512, 11,  4, 10,  1), 		 // 33904 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 11,  4, 10,  1), 		 // 47207 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  524, 11,  4, 10,  1), 		 // 76229 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  504, 22,  2, 10,  1), 		 // 146924 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  545, 46,  1, 11,  1), 		 // 335538 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  508,  1, 24,  5,  2), 		 // 2518 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 3255 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 3307 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  516,  2, 16,  5,  2), 		 // 4297 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  508,  3, 12,  5,  2), 		 // 4639 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  485,  3, 12,  9,  1), 		 // 5912 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 6058 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  491,  3, 12,  9,  1), 		 // 8623 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  484,  4, 10,  9,  1), 		 // 11043 mops, 5.4e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  498,  4, 10,  9,  1), 		 // 11213 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  501,  5,  8,  9,  1), 		 // 13779 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  5,  8,  9,  1), 		 // 15997 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  510,  6,  7, 10,  1), 		 // 19055 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  544,  7,  6, 11,  1), 		 // 22791 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  512, 11,  4, 10,  1), 		 // 33904 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 11,  4, 10,  1), 		 // 47207 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  524, 11,  4, 10,  1), 		 // 76229 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  504, 22,  2, 10,  1), 		 // 146924 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  545, 46,  1, 11,  1), 		 // 335538 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 4386 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 4403 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  518,  2, 16,  5,  2), 		 // 4516 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  536,  2, 16,  5,  2), 		 // 5924 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  487,  3, 12,  9,  1), 		 // 7976 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 8321 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  496,  3, 12,  9,  1), 		 // 11638 mops, 5.4e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  485,  4, 10,  9,  1), 		 // 14836 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4, 10, 10,  1), 		 // 15202 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  5,  8, 10,  1), 		 // 18731 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8, 10,  1), 		 // 21833 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  551,  6,  7, 11,  1), 		 // 26655 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  497,  9,  5,  9,  1), 		 // 36922 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  552, 11,  4, 11,  1), 		 // 47296 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 11,  4, 10,  1), 		 // 64064 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  541, 22,  2, 11,  1), 		 // 128913 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  521, 22,  2, 10,  1), 		 // 199571 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  539, 46,  1, 11,  1), 		 // 856693 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 4386 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 4403 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  518,  2, 16,  5,  2), 		 // 4516 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  536,  2, 16,  5,  2), 		 // 5924 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  487,  3, 12,  9,  1), 		 // 7976 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 8321 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  496,  3, 12,  9,  1), 		 // 11638 mops, 5.4e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  485,  4, 10,  9,  1), 		 // 14836 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4, 10, 10,  1), 		 // 15202 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  5,  8, 10,  1), 		 // 18731 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8, 10,  1), 		 // 21833 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  551,  6,  7, 11,  1), 		 // 26655 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  497,  9,  5,  9,  1), 		 // 36922 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  552, 11,  4, 11,  1), 		 // 47296 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 11,  4, 10,  1), 		 // 64064 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  541, 22,  2, 11,  1), 		 // 128913 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  521, 22,  2, 10,  1), 		 // 199571 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  539, 46,  1, 11,  1), 		 // 856693 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 4386 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 4403 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  518,  2, 16,  5,  2), 		 // 4516 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  536,  2, 16,  5,  2), 		 // 5924 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  487,  3, 12,  9,  1), 		 // 7976 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 8321 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  496,  3, 12,  9,  1), 		 // 11638 mops, 5.4e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  485,  4, 10,  9,  1), 		 // 14836 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4, 10, 10,  1), 		 // 15202 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  5,  8, 10,  1), 		 // 18731 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8, 10,  1), 		 // 21833 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  551,  6,  7, 11,  1), 		 // 26655 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  497,  9,  5,  9,  1), 		 // 36922 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  552, 11,  4, 11,  1), 		 // 47296 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 11,  4, 10,  1), 		 // 64064 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  541, 22,  2, 11,  1), 		 // 128913 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  521, 22,  2, 10,  1), 		 // 199571 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  539, 46,  1, 11,  1), 		 // 856693 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 5843 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 // 5889 mops, 5.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 // 6197 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 8260 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 // 8578 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 10665 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 13602 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  502,  3, 12, 10,  1), 		 // 15661 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 19832 mops, 5.4e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 20757 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 25883 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 33339 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 38682 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 49672 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 70130 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 110410 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 179153 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 283264 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 5843 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 // 5889 mops, 5.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 // 6197 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 8260 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 // 8578 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 10665 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 13602 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  502,  3, 12, 10,  1), 		 // 15661 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 19832 mops, 5.4e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 20757 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 25883 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 33339 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 38682 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 49672 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 70130 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 110410 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 179153 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 283264 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 5843 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 // 5889 mops, 5.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 // 6197 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 8260 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 // 8578 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 10665 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 13602 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  502,  3, 12, 10,  1), 		 // 15661 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 19832 mops, 5.4e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 20757 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 25883 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 33339 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 38682 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 49672 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 70130 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 110410 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 179153 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 283264 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 15,  4,  2), 		 // 5843 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  499,  2, 16,  5,  2), 		 // 5889 mops, 5.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  542,  2, 16,  5,  2), 		 // 6197 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 8260 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  531,  3, 12,  5,  2), 		 // 8578 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 10665 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 13602 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  502,  3, 12, 10,  1), 		 // 15661 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  487,  4, 10,  9,  1), 		 // 19832 mops, 5.4e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  528,  4, 10, 10,  1), 		 // 20757 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  545,  5,  8, 11,  1), 		 // 25883 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  490,  6,  7,  9,  1), 		 // 33339 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  7,  6,  9,  1), 		 // 38682 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  505,  9,  5, 10,  1), 		 // 49672 mops, 6.0e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  510,  9,  5, 10,  1), 		 // 70130 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  539, 14,  3, 11,  1), 		 // 110410 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  499, 15,  3, 10,  1), 		 // 179153 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  541, 23,  2, 11,  1), 		 // 283264 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 7436 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 7446 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  500,  2, 16,  5,  2), 		 // 7500 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  503,  2, 16,  5,  2), 		 // 9659 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 10500 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  572,  3, 12,  5,  2), 		 // 11377 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  492,  3, 12,  9,  1), 		 // 13547 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  541,  4, 10, 10,  1), 		 // 18405 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 20025 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  489,  4, 10,  9,  1), 		 // 25071 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  490,  5,  8,  9,  1), 		 // 30714 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  491,  5,  8,  9,  1), 		 // 35501 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  493,  6,  7,  9,  1), 		 // 42093 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  499,  7,  6,  9,  1), 		 // 48913 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  518,  9,  5, 10,  1), 		 // 63267 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  530,  9,  5, 10,  1), 		 // 89825 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  502, 15,  3, 10,  1), 		 // 142881 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  507, 15,  3, 10,  1), 		 // 226335 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  513, 45,  1, 10,  1), 		 // 670307 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_parameters.ref-20-06-2022

@@ -0,0 +1,546 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  499,  1, 23,  4,  2), 		 //  129 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  505,  1, 23,  4,  2), 		 //  130 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 //  135 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  572,  1, 23,  5,  2), 		 //  209 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 //  322 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  2, 16,  4,  2), 		 //  322 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  2, 16,  4,  2), 		 //  323 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 //  324 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 //  332 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 //  454 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 //  459 mops, 5.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 //  491 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  510,  3, 12,  5,  2), 		 //  615 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  531,  4,  9,  5,  2), 		 //  811 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 1163 mops, 5.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 1180 mops, 5.6e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 1440 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 1786 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 2292 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 2659 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 3591 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 5166 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 9749 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 16145 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  504,  1, 23,  5,  2), 		 //  300 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  508,  1, 23,  5,  2), 		 //  424 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  521,  1, 23,  5,  2), 		 //  556 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 //  701 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 //  702 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 //  703 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  503,  2, 16,  5,  2), 		 //  710 mops, 5.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  507,  2, 16,  5,  2), 		 //  925 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  496,  3, 12,  5,  2), 		 //  991 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  509,  3, 12,  5,  2), 		 // 1005 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  488,  3, 12,  9,  1), 		 // 1293 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  503,  3, 12,  9,  1), 		 // 1615 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  507,  3, 12, 10,  1), 		 // 2229 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  488,  4,  9,  9,  1), 		 // 2433 mops, 5.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  486,  5,  8,  9,  1), 		 // 2975 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  5,  8, 10,  1), 		 // 3073 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  501,  6,  7, 10,  1), 		 // 4148 mops, 5.8e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  508,  7,  6, 10,  1), 		 // 4827 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  541,  9,  5, 11,  1), 		 // 6330 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  526, 14,  3, 10,  1), 		 // 9534 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  519, 14,  3, 10,  1), 		 // 13375 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  539, 15,  3, 11,  1), 		 // 23092 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  525, 44,  1, 10,  1), 		 // 65683 mops, 6.1e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 //  620 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  572,  1, 23,  5,  2), 		 //  920 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 1403 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 1404 mops, 5.4e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 1405 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 1410 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 1449 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 // 1943 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 1991 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 // 2139 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  499,  3, 12,  9,  1), 		 // 2618 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  531,  4,  9,  5,  2), 		 // 3455 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 4845 mops, 5.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 4918 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 5994 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 7410 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 9481 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 11007 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 14859 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 21167 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 39621 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 65542 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  510,  1, 23,  5,  2), 		 // 1683 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 2161 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 2162 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 2165 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  500,  2, 16,  5,  2), 		 // 2181 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  2, 16,  5,  2), 		 // 2818 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  495,  3, 12,  5,  2), 		 // 3046 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  504,  3, 12,  5,  2), 		 // 3078 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  486,  3, 12,  9,  1), 		 // 3946 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  527,  3, 12,  5,  2), 		 // 4083 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 5902 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  486,  4,  9,  9,  1), 		 // 7378 mops, 5.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  4,  9, 10,  1), 		 // 7600 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  503,  5,  8,  9,  1), 		 // 9205 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  6,  7,  9,  1), 		 // 12483 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  498,  7,  6, 10,  1), 		 // 14495 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  509,  9,  5, 10,  1), 		 // 18597 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  544,  9,  5, 11,  1), 		 // 27086 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  503, 14,  3, 10,  1), 		 // 39817 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  530, 22,  2, 10,  1), 		 // 63530 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  527, 43,  1, 10,  1), 		 // 193915 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  510,  1, 23,  5,  2), 		 // 1683 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 2161 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 2162 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 2165 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  500,  2, 16,  5,  2), 		 // 2181 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  2, 16,  5,  2), 		 // 2818 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  495,  3, 12,  5,  2), 		 // 3046 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  504,  3, 12,  5,  2), 		 // 3078 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  486,  3, 12,  9,  1), 		 // 3946 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  527,  3, 12,  5,  2), 		 // 4083 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 5902 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  486,  4,  9,  9,  1), 		 // 7378 mops, 5.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  4,  9, 10,  1), 		 // 7600 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  503,  5,  8,  9,  1), 		 // 9205 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  494,  6,  7,  9,  1), 		 // 12483 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  498,  7,  6, 10,  1), 		 // 14495 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  509,  9,  5, 10,  1), 		 // 18597 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  544,  9,  5, 11,  1), 		 // 27086 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  503, 14,  3, 10,  1), 		 // 39817 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  530, 22,  2, 10,  1), 		 // 63530 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  527, 43,  1, 10,  1), 		 // 193915 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  529,  1, 23,  5,  2), 		 // 2586 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 // 3251 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  504,  2, 16,  5,  2), 		 // 3287 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 4263 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  496,  3, 12,  5,  2), 		 // 4575 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 4660 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 5939 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  508,  3, 12,  9,  1), 		 // 7428 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 10218 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  4,  9,  9,  1), 		 // 11104 mops, 5.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  487,  5,  8,  9,  1), 		 // 13575 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  528,  5,  8, 10,  1), 		 // 14190 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  6,  7, 10,  1), 		 // 18957 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  515,  7,  6, 10,  1), 		 // 22123 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539,  8,  5, 11,  1), 		 // 32673 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  549, 14,  3, 11,  1), 		 // 44371 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  536, 14,  3, 11,  1), 		 // 61678 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  517, 22,  2, 10,  1), 		 // 139646 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 44,  1, 11,  1), 		 // 305043 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  529,  1, 23,  5,  2), 		 // 2586 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 // 3251 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  504,  2, 16,  5,  2), 		 // 3287 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 4263 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  496,  3, 12,  5,  2), 		 // 4575 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 4660 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 5939 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  508,  3, 12,  9,  1), 		 // 7428 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 10218 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  4,  9,  9,  1), 		 // 11104 mops, 5.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  487,  5,  8,  9,  1), 		 // 13575 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  528,  5,  8, 10,  1), 		 // 14190 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  6,  7, 10,  1), 		 // 18957 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  515,  7,  6, 10,  1), 		 // 22123 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539,  8,  5, 11,  1), 		 // 32673 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  549, 14,  3, 11,  1), 		 // 44371 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  536, 14,  3, 11,  1), 		 // 61678 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  517, 22,  2, 10,  1), 		 // 139646 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 44,  1, 11,  1), 		 // 305043 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  529,  1, 23,  5,  2), 		 // 2586 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 3242 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 3243 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  495,  2, 16,  5,  2), 		 // 3251 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  504,  2, 16,  5,  2), 		 // 3287 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  509,  2, 16,  5,  2), 		 // 4263 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  496,  3, 12,  5,  2), 		 // 4575 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 4660 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  489,  3, 12,  9,  1), 		 // 5939 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  508,  3, 12,  9,  1), 		 // 7428 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  513,  3, 12, 10,  1), 		 // 10218 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  4,  9,  9,  1), 		 // 11104 mops, 5.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  487,  5,  8,  9,  1), 		 // 13575 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  528,  5,  8, 10,  1), 		 // 14190 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  505,  6,  7, 10,  1), 		 // 18957 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  515,  7,  6, 10,  1), 		 // 22123 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539,  8,  5, 11,  1), 		 // 32673 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  549, 14,  3, 11,  1), 		 // 44371 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  536, 14,  3, 11,  1), 		 // 61678 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  517, 22,  2, 10,  1), 		 // 139646 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 44,  1, 11,  1), 		 // 305043 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 4381 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 4397 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  519,  2, 16,  5,  2), 		 // 5809 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 6192 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  524,  3, 12,  5,  2), 		 // 6380 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  493,  3, 12,  9,  1), 		 // 8032 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  526,  3, 12, 10,  1), 		 // 10208 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  561,  3, 12, 11,  1), 		 // 14446 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  492,  4,  9,  9,  1), 		 // 14950 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  5,  8,  9,  1), 		 // 18255 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  510,  5,  8, 10,  1), 		 // 21585 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  525,  6,  7, 10,  1), 		 // 25943 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  501,  8,  5, 10,  1), 		 // 33168 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  499, 11,  4, 10,  1), 		 // 44863 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  503, 11,  4, 10,  1), 		 // 63310 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 15,  3, 11,  1), 		 // 88197 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 22,  2, 10,  1), 		 // 195805 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  533, 44,  1, 10,  1), 		 // 790841 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 4381 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 4397 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  519,  2, 16,  5,  2), 		 // 5809 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 6192 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  524,  3, 12,  5,  2), 		 // 6380 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  493,  3, 12,  9,  1), 		 // 8032 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  526,  3, 12, 10,  1), 		 // 10208 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  561,  3, 12, 11,  1), 		 // 14446 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  492,  4,  9,  9,  1), 		 // 14950 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  5,  8,  9,  1), 		 // 18255 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  510,  5,  8, 10,  1), 		 // 21585 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  525,  6,  7, 10,  1), 		 // 25943 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  501,  8,  5, 10,  1), 		 // 33168 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  499, 11,  4, 10,  1), 		 // 44863 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  503, 11,  4, 10,  1), 		 // 63310 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 15,  3, 11,  1), 		 // 88197 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 22,  2, 10,  1), 		 // 195805 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  533, 44,  1, 10,  1), 		 // 790841 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  497,  2, 16,  4,  2), 		 // 4379 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 4381 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  496,  2, 16,  5,  2), 		 // 4397 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  519,  2, 16,  5,  2), 		 // 5809 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  498,  3, 12,  5,  2), 		 // 6192 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  524,  3, 12,  5,  2), 		 // 6380 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  493,  3, 12,  9,  1), 		 // 8032 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  526,  3, 12, 10,  1), 		 // 10208 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  561,  3, 12, 11,  1), 		 // 14446 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  492,  4,  9,  9,  1), 		 // 14950 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  489,  5,  8,  9,  1), 		 // 18255 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  510,  5,  8, 10,  1), 		 // 21585 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  525,  6,  7, 10,  1), 		 // 25943 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  501,  8,  5, 10,  1), 		 // 33168 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  499, 11,  4, 10,  1), 		 // 44863 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  503, 11,  4, 10,  1), 		 // 63310 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 15,  3, 11,  1), 		 // 88197 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  501, 22,  2, 10,  1), 		 // 195805 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  533, 44,  1, 10,  1), 		 // 790841 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 5874 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 6039 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 // 8030 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 8279 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 // 8915 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  499,  3, 12,  9,  1), 		 // 10789 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  520,  4,  9, 10,  1), 		 // 14239 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 19767 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 20072 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 24452 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 30176 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 38562 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 44776 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 60431 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 85682 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 159752 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 264104 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 5874 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 6039 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 // 8030 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 8279 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 // 8915 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  499,  3, 12,  9,  1), 		 // 10789 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  520,  4,  9, 10,  1), 		 // 14239 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 19767 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 20072 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 24452 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 30176 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 38562 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 44776 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 60431 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 85682 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 159752 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 264104 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 5874 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 6039 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 // 8030 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 8279 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 // 8915 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  499,  3, 12,  9,  1), 		 // 10789 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  520,  4,  9, 10,  1), 		 // 14239 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 19767 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 20072 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 24452 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 30176 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 38562 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 44776 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 60431 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 85682 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 159752 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 264104 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  493,  2, 16,  5,  2), 		 // 5846 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 5853 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  497,  2, 16,  5,  2), 		 // 5874 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 6039 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  550,  2, 16,  5,  2), 		 // 8030 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  500,  3, 12,  5,  2), 		 // 8279 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  566,  3, 12,  5,  2), 		 // 8915 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  499,  3, 12,  9,  1), 		 // 10789 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  520,  4,  9, 10,  1), 		 // 14239 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  484,  4,  9,  9,  1), 		 // 19767 mops, 5.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  4,  9,  9,  1), 		 // 20072 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  493,  5,  8,  9,  1), 		 // 24452 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  555,  5,  8, 11,  1), 		 // 30176 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  491,  7,  6,  9,  1), 		 // 38562 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  513,  8,  5, 10,  1), 		 // 44776 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  509, 11,  4, 10,  1), 		 // 60431 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  518, 11,  4, 10,  1), 		 // 85682 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  515, 14,  3, 10,  1), 		 // 159752 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  513, 22,  2, 10,  1), 		 // 264104 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  494,  2, 16,  5,  2), 		 // 7446 mops, 5.5e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  498,  2, 16,  5,  2), 		 // 7482 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 7854 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  495,  3, 12,  5,  2), 		 // 10439 mops, 5.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  502,  3, 12,  5,  2), 		 // 10524 mops, 5.4e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  485,  3, 12,  9,  1), 		 // 13437 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 13775 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  556,  4,  9, 11,  1), 		 // 18743 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  485,  4,  9,  9,  1), 		 // 24962 mops, 5.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  503,  4,  9, 10,  1), 		 // 25494 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  498,  5,  8,  9,  1), 		 // 30978 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  492,  6,  7,  9,  1), 		 // 42049 mops, 5.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  495,  7,  6,  9,  1), 		 // 48711 mops, 5.5e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  544,  8,  5, 11,  1), 		 // 58115 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  529, 11,  4, 10,  1), 		 // 77459 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  498, 14,  3, 10,  1), 		 // 133103 mops, 5.8e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  553, 14,  3, 11,  1), 		 // 207661 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  545, 22,  2, 11,  1), 		 // 341049 mops, 6.3e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_parameters.ref-24-06-2022

@@ -0,0 +1,546 @@
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  516,  1, 23,  4,  2), 		 //  131 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  523,  1, 23,  4,  2), 		 //  132 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  547,  1, 23,  5,  2), 		 //  138 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  578,  1, 23, 11,  1), 		 //  224 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  514,  2, 16,  4,  2), 		 //  328 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 //  328 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  516,  2, 16,  4,  2), 		 //  329 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 //  330 mops, 5.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 //  339 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 //  464 mops, 4.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 //  467 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  587,  3, 12,  5,  2), 		 //  501 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  528,  3, 12,  5,  2), 		 //  626 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 //  825 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 1184 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 1202 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 1466 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 1836 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 2332 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 2710 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 3656 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 5268 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 9931 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 16445 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  522,  1, 23,  5,  2), 		 //  307 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  526,  1, 23,  5,  2), 		 //  434 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  540,  1, 23,  5,  2), 		 //  569 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 //  716 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 //  716 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 //  718 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 //  724 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  525,  2, 16,  5,  2), 		 //  945 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  513,  3, 12,  5,  2), 		 // 1010 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  527,  3, 12,  5,  2), 		 // 1026 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 1319 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  521,  3, 12,  9,  1), 		 // 1647 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 2273 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  505,  4,  9,  9,  1), 		 // 2477 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 3031 mops, 5.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  5,  8, 10,  1), 		 // 3133 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  519,  6,  7, 10,  1), 		 // 4225 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  527,  7,  6, 10,  1), 		 // 4919 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  571,  9,  5, 11,  1), 		 // 6513 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  545, 14,  3, 10,  1), 		 // 9708 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  540, 14,  3, 10,  1), 		 // 13645 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  568, 15,  3, 11,  1), 		 // 23714 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  547, 44,  1, 10,  1), 		 // 67018 mops, 6.1e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  547,  1, 23,  5,  2), 		 //  636 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  1, 23, 11,  1), 		 //  981 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  514,  2, 16,  4,  2), 		 // 1431 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 1432 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 1434 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 1441 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 1481 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 2001 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 2029 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  3, 12,  5,  2), 		 // 2187 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  528,  3, 12,  5,  2), 		 // 2670 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 3516 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 4934 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 5012 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 6107 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 7660 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 9656 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 11226 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 15138 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 21596 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 40376 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 66778 mops, 6.1e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 // 1722 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 2212 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  517,  2, 16,  5,  2), 		 // 2225 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 2878 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 3106 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  521,  3, 12,  5,  2), 		 // 3138 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  503,  3, 12,  9,  1), 		 // 4023 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  546,  3, 12,  5,  2), 		 // 4168 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  503,  4,  9,  9,  1), 		 // 7515 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  531,  4,  9, 10,  1), 		 // 7753 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8,  9,  1), 		 // 9380 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  6,  7,  9,  1), 		 // 12717 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  7,  6, 10,  1), 		 // 14763 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  528,  9,  5, 10,  1), 		 // 18952 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  524, 14,  3, 10,  1), 		 // 28864 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522, 14,  3, 10,  1), 		 // 40559 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551, 22,  2, 10,  1), 		 // 64791 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  524, 44,  1, 10,  1), 		 // 197831 mops, 5.7e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 // 1722 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 2212 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  517,  2, 16,  5,  2), 		 // 2225 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 2878 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 3106 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  521,  3, 12,  5,  2), 		 // 3138 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  503,  3, 12,  9,  1), 		 // 4023 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  546,  3, 12,  5,  2), 		 // 4168 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  503,  4,  9,  9,  1), 		 // 7515 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  531,  4,  9, 10,  1), 		 // 7753 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8,  9,  1), 		 // 9380 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  6,  7,  9,  1), 		 // 12717 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  7,  6, 10,  1), 		 // 14763 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  528,  9,  5, 10,  1), 		 // 18952 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  524, 14,  3, 10,  1), 		 // 28864 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522, 14,  3, 10,  1), 		 // 40559 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551, 22,  2, 10,  1), 		 // 64791 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  524, 44,  1, 10,  1), 		 // 197831 mops, 5.7e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 7600 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  516,  2, 16,  5,  2), 		 // 7645 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  562,  2, 16,  5,  2), 		 // 8063 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 10646 mops, 5.4e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  519,  3, 12,  5,  2), 		 // 10731 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  3, 12,  9,  1), 		 // 13703 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 14050 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  575,  4,  9, 11,  1), 		 // 19118 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  502,  4,  9,  9,  1), 		 // 25428 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  523,  4,  9,  9,  1), 		 // 26003 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  5,  8,  9,  1), 		 // 31572 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  509,  6,  7,  9,  1), 		 // 42799 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  7,  6, 10,  1), 		 // 49610 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  587,  8,  5, 11,  1), 		 // 60569 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  550, 11,  4, 10,  1), 		 // 79059 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516, 14,  3, 10,  1), 		 // 135475 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  531, 22,  2, 10,  1), 		 // 213514 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  564, 23,  2, 11,  1), 		 // 362490 mops, 6.3e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_pbs_2022-6-27_112

@@ -0,0 +1,547 @@
+{ /* Security level: 112 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  450,  1, 23,  4,  2), 		 //  121 mops, 4.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  454,  1, 23,  4,  2), 		 //  121 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  469,  1, 23,  5,  2), 		 //  126 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  483,  1, 23,  5,  2), 		 //  187 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  451,  2, 16,  4,  2), 		 //  305 mops, 2.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  457,  2, 16,  4,  2), 		 //  308 mops, 5.6e-6 errors
+    /*  6 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 //  305 mops, 3.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 //  306 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 //  312 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 //  420 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 //  434 mops, 4.4e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 //  458 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 //  581 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  476,  4,  9,  5,  2), 		 //  767 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 1, 11,  450,  4,  9,  5,  2), 		 // 1110 mops, 2.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 1122 mops, 2.6e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  450,  5,  8,  9,  1), 		 // 1361 mops, 3.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 1643 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 2154 mops, 4.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 2513 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 3407 mops, 5.7e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 4879 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 9237 mops, 5.8e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 15291 mops, 6.2e-5 errors
+    /* 24 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 65432 mops, 6.3e-5 errors
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  453,  1, 23,  5,  2), 		 //  279 mops, 5.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  455,  1, 23,  5,  2), 		 //  395 mops, 5.4e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  464,  1, 23,  5,  2), 		 //  516 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 //  662 mops, 2.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 //  662 mops, 3.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 //  662 mops, 5.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  451,  2, 16,  5,  2), 		 //  666 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  454,  2, 16,  5,  2), 		 //  869 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  451,  3, 12,  4,  2), 		 //  936 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 //  947 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 1223 mops, 4.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  491,  3, 12, 11,  1), 		 // 1305 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  479,  3, 12, 10,  1), 		 // 1869 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 2319 mops, 3.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  477,  4,  9, 10,  1), 		 // 2407 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  460,  5,  8, 10,  1), 		 // 2896 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  450,  6,  7,  9,  1), 		 // 3928 mops, 4.5e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  453,  7,  6, 10,  1), 		 // 4559 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  471,  9,  5, 10,  1), 		 // 5899 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  467, 14,  3, 10,  1), 		 // 8992 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  460, 14,  3, 10,  1), 		 // 12620 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  469, 15,  3, 10,  1), 		 // 21587 mops, 6.0e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  463, 44,  1, 10,  1), 		 // 61920 mops, 6.2e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  469,  1, 23,  5,  2), 		 //  572 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  483,  1, 23,  5,  2), 		 //  821 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 1325 mops, 2.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 1325 mops, 3.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 1325 mops, 3.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 // 1328 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 1353 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 // 1789 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 1878 mops, 4.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 // 1989 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 // 2466 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  476,  4,  9,  5,  2), 		 // 3256 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  451,  4,  9,  4,  2), 		 // 4636 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 4666 mops, 2.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  453,  5,  8,  5,  2), 		 // 5713 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 6797 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 9004 mops, 4.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 10382 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 14068 mops, 5.7e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 19960 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 37507 mops, 5.8e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 62017 mops, 6.2e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 263532 mops, 6.3e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  457,  1, 23,  5,  2), 		 // 1568 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 2.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 3.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 4.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  450,  2, 16,  5,  2), 		 // 2049 mops, 3.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  501,  2, 16,  5,  2), 		 // 2183 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  450,  3, 12,  4,  2), 		 // 2877 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  453,  3, 12,  5,  2), 		 // 2898 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 3739 mops, 2.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  470,  3, 12,  5,  2), 		 // 3828 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  456,  3, 12, 10,  1), 		 // 5534 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 7046 mops, 2.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  456,  4,  9, 10,  1), 		 // 7147 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  451,  5,  8,  9,  1), 		 // 8701 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  453,  6,  7,  5,  2), 		 // 11906 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450,  7,  6,  9,  1), 		 // 13768 mops, 3.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  454,  9,  5, 10,  1), 		 // 17569 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  499, 11,  4, 11,  1), 		 // 22322 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  450, 14,  3, 10,  1), 		 // 37748 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  468, 22,  2, 10,  1), 		 // 59807 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  464, 43,  1, 10,  1), 		 // 182586 mops, 6.1e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  457,  1, 23,  5,  2), 		 // 1568 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 2.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 3.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 2038 mops, 4.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  450,  2, 16,  5,  2), 		 // 2049 mops, 3.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  501,  2, 16,  5,  2), 		 // 2183 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  450,  3, 12,  4,  2), 		 // 2877 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  453,  3, 12,  5,  2), 		 // 2898 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 3739 mops, 2.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  470,  3, 12,  5,  2), 		 // 3828 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  456,  3, 12, 10,  1), 		 // 5534 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 7046 mops, 2.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  456,  4,  9, 10,  1), 		 // 7147 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  451,  5,  8,  9,  1), 		 // 8701 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  453,  6,  7,  5,  2), 		 // 11906 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450,  7,  6,  9,  1), 		 // 13768 mops, 3.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  454,  9,  5, 10,  1), 		 // 17569 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  499, 11,  4, 11,  1), 		 // 22322 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  450, 14,  3, 10,  1), 		 // 37748 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  468, 22,  2, 10,  1), 		 // 59807 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  464, 43,  1, 10,  1), 		 // 182586 mops, 6.1e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  470,  1, 23,  5,  2), 		 // 2394 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 2.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 3.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  452,  2, 16,  5,  2), 		 // 3082 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 3999 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  452,  3, 12,  4,  2), 		 // 4326 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  460,  3, 12,  5,  2), 		 // 4384 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5609 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  455,  3, 12,  9,  1), 		 // 6991 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  459,  3, 12, 10,  1), 		 // 9621 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 10569 mops, 4.5e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 12973 mops, 3.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  468,  5,  8, 10,  1), 		 // 13315 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  451,  6,  7,  9,  1), 		 // 17885 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  457,  7,  6, 10,  1), 		 // 20825 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  492,  9,  5, 11,  1), 		 // 27436 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  480, 14,  3, 10,  1), 		 // 41440 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  469, 14,  3, 10,  1), 		 // 57735 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  487, 15,  3, 11,  1), 		 // 99369 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  474, 44,  1, 10,  1), 		 // 282952 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  470,  1, 23,  5,  2), 		 // 2394 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 2.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 3.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  452,  2, 16,  5,  2), 		 // 3082 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 3999 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  452,  3, 12,  4,  2), 		 // 4326 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  460,  3, 12,  5,  2), 		 // 4384 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5609 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  455,  3, 12,  9,  1), 		 // 6991 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  459,  3, 12, 10,  1), 		 // 9621 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 10569 mops, 4.5e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 12973 mops, 3.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  468,  5,  8, 10,  1), 		 // 13315 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  451,  6,  7,  9,  1), 		 // 17885 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  457,  7,  6, 10,  1), 		 // 20825 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  492,  9,  5, 11,  1), 		 // 27436 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  480, 14,  3, 10,  1), 		 // 41440 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  469, 14,  3, 10,  1), 		 // 57735 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  487, 15,  3, 11,  1), 		 // 99369 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  474, 44,  1, 10,  1), 		 // 282952 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  470,  1, 23,  5,  2), 		 // 2394 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 2.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 3.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 3058 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  452,  2, 16,  5,  2), 		 // 3082 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 3999 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  452,  3, 12,  4,  2), 		 // 4326 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  460,  3, 12,  5,  2), 		 // 4384 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5609 mops, 5.4e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  455,  3, 12,  9,  1), 		 // 6991 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  459,  3, 12, 10,  1), 		 // 9621 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 10569 mops, 4.5e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 12973 mops, 3.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  468,  5,  8, 10,  1), 		 // 13315 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  451,  6,  7,  9,  1), 		 // 17885 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  457,  7,  6, 10,  1), 		 // 20825 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  492,  9,  5, 11,  1), 		 // 27436 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  480, 14,  3, 10,  1), 		 // 41440 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  469, 14,  3, 10,  1), 		 // 57735 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  487, 15,  3, 11,  1), 		 // 99369 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  474, 44,  1, 10,  1), 		 // 282952 mops, 6.2e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  451,  2, 16,  4,  2), 		 // 4134 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 4182 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5432 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5845 mops, 2.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  470,  3, 12,  5,  2), 		 // 5990 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  453,  3, 12,  5,  2), 		 // 7576 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  479,  3, 12,  5,  2), 		 // 9570 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  488,  3, 12, 10,  1), 		 // 13332 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  452,  4,  9,  5,  2), 		 // 14212 mops, 5.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 17404 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  454,  5,  8, 10,  1), 		 // 20323 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  462,  6,  7, 10,  1), 		 // 24283 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  485,  7,  6, 11,  1), 		 // 28780 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 42616 mops, 3.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 59959 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  469, 15,  3, 10,  1), 		 // 82628 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  504, 22,  2, 11,  1), 		 // 184400 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  468, 44,  1, 10,  1), 		 // 743887 mops, 6.0e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  451,  2, 16,  4,  2), 		 // 4134 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 4182 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5432 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5845 mops, 2.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  470,  3, 12,  5,  2), 		 // 5990 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  453,  3, 12,  5,  2), 		 // 7576 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  479,  3, 12,  5,  2), 		 // 9570 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  488,  3, 12, 10,  1), 		 // 13332 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  452,  4,  9,  5,  2), 		 // 14212 mops, 5.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 17404 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  454,  5,  8, 10,  1), 		 // 20323 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  462,  6,  7, 10,  1), 		 // 24283 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  485,  7,  6, 11,  1), 		 // 28780 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 42616 mops, 3.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 59959 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  469, 15,  3, 10,  1), 		 // 82628 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  504, 22,  2, 11,  1), 		 // 184400 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  468, 44,  1, 10,  1), 		 // 743887 mops, 6.0e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 4129 mops, 3.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  451,  2, 16,  4,  2), 		 // 4134 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  456,  2, 16,  5,  2), 		 // 4182 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5432 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 5845 mops, 2.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  470,  3, 12,  5,  2), 		 // 5990 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  453,  3, 12,  5,  2), 		 // 7576 mops, 5.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  479,  3, 12,  5,  2), 		 // 9570 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  488,  3, 12, 10,  1), 		 // 13332 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  452,  4,  9,  5,  2), 		 // 14212 mops, 5.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  450,  5,  8,  5,  2), 		 // 17404 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  454,  5,  8, 10,  1), 		 // 20323 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  462,  6,  7, 10,  1), 		 // 24283 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  485,  7,  6, 11,  1), 		 // 28780 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 42616 mops, 3.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  450, 11,  4,  9,  1), 		 // 59959 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  469, 15,  3, 10,  1), 		 // 82628 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  504, 22,  2, 11,  1), 		 // 184400 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  468, 44,  1, 10,  1), 		 // 743887 mops, 6.0e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 // 5523 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5631 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 // 7382 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 7798 mops, 4.4e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 // 8270 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 // 10155 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  466,  4,  9, 10,  1), 		 // 13400 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  451,  4,  9,  4,  2), 		 // 18907 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 19027 mops, 2.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  453,  5,  8,  5,  2), 		 // 23291 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 27647 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 36794 mops, 4.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 42194 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 57161 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 80739 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 151158 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 249792 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 1057773 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 // 5523 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5631 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 // 7382 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 7798 mops, 4.4e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 // 8270 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 // 10155 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  466,  4,  9, 10,  1), 		 // 13400 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  451,  4,  9,  4,  2), 		 // 18907 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 19027 mops, 2.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  453,  5,  8,  5,  2), 		 // 23291 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 27647 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 36794 mops, 4.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 42194 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 57161 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 80739 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 151158 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 249792 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 1057773 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 // 5523 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5631 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 // 7382 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 7798 mops, 4.4e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 // 8270 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 // 10155 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  466,  4,  9, 10,  1), 		 // 13400 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  451,  4,  9,  4,  2), 		 // 18907 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 19027 mops, 2.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  453,  5,  8,  5,  2), 		 // 23291 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 27647 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 36794 mops, 4.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 42194 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 57161 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 80739 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 151158 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 249792 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 1057773 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 5509 mops, 3.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  452,  2, 16,  4,  2), 		 // 5523 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  463,  2, 16,  5,  2), 		 // 5631 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  478,  2, 16,  5,  2), 		 // 7382 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  450,  3, 12,  5,  2), 		 // 7798 mops, 4.4e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  499,  3, 12,  5,  2), 		 // 8270 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  457,  3, 12,  5,  2), 		 // 10155 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  466,  4,  9, 10,  1), 		 // 13400 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  451,  4,  9,  4,  2), 		 // 18907 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  4,  9,  9,  1), 		 // 19027 mops, 2.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  453,  5,  8,  5,  2), 		 // 23291 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  472,  5,  8, 10,  1), 		 // 27647 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 1, 11,  450,  7,  6,  9,  1), 		 // 36794 mops, 4.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  456,  8,  5, 10,  1), 		 // 42194 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  455, 11,  4, 10,  1), 		 // 57161 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  459, 11,  4, 10,  1), 		 // 80739 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  459, 14,  3, 10,  1), 		 // 151158 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  456, 22,  2, 10,  1), 		 // 249792 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  480, 45,  1, 10,  1), 		 // 1057773 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  450,  2, 16,  4,  2), 		 // 7011 mops, 4.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  450,  2, 16,  5,  2), 		 // 7046 mops, 2.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  474,  2, 16,  5,  2), 		 // 7264 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  450,  3, 12,  4,  2), 		 // 9855 mops, 5.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  451,  3, 12,  5,  2), 		 // 9902 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  452,  3, 12,  4,  2), 		 // 12745 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  453,  3, 12,  9,  1), 		 // 12938 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  496,  4,  9, 11,  1), 		 // 17561 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  450,  4,  9,  5,  2), 		 // 23862 mops, 1.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  451,  4,  9,  9,  1), 		 // 24030 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  450,  5,  8,  9,  1), 		 // 29395 mops, 3.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  451,  6,  7,  5,  2), 		 // 40098 mops, 5.9e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  450,  7,  6,  9,  1), 		 // 46437 mops, 1.5e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  471,  8,  5, 10,  1), 		 // 53911 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  467, 11,  4, 10,  1), 		 // 72735 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  480, 11,  4, 11,  1), 		 // 103600 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  477, 14,  3, 10,  1), 		 // 192994 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  471, 22,  2, 10,  1), 		 // 317711 mops, 6.2e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_pbs_2022-6-27_128

@@ -0,0 +1,547 @@
+{ /* Security level: 128 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  516,  1, 23,  4,  2), 		 //  131 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  523,  1, 23,  4,  2), 		 //  132 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  547,  1, 23,  5,  2), 		 //  138 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  578,  1, 23, 11,  1), 		 //  224 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  514,  2, 16,  4,  2), 		 //  328 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 //  328 mops, 5.5e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  516,  2, 16,  4,  2), 		 //  329 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 //  330 mops, 5.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 //  339 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 //  464 mops, 4.8e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 //  467 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  587,  3, 12,  5,  2), 		 //  501 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  528,  3, 12,  5,  2), 		 //  626 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 //  825 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 1184 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 1202 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 1466 mops, 5.7e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 1836 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 2332 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 2710 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 3656 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 5268 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 9931 mops, 6.0e-5 errors
+    /* 23 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 16445 mops, 6.1e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  522,  1, 23,  5,  2), 		 //  307 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  526,  1, 23,  5,  2), 		 //  434 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  540,  1, 23,  5,  2), 		 //  569 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 //  716 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 //  716 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 //  718 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 //  724 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  525,  2, 16,  5,  2), 		 //  945 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  513,  3, 12,  5,  2), 		 // 1010 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  527,  3, 12,  5,  2), 		 // 1026 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 1319 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  521,  3, 12,  9,  1), 		 // 1647 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  525,  3, 12, 10,  1), 		 // 2273 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  505,  4,  9,  9,  1), 		 // 2477 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 3031 mops, 5.1e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  5,  8, 10,  1), 		 // 3133 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  519,  6,  7, 10,  1), 		 // 4225 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  527,  7,  6, 10,  1), 		 // 4919 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  571,  9,  5, 11,  1), 		 // 6513 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  545, 14,  3, 10,  1), 		 // 9708 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  540, 14,  3, 10,  1), 		 // 13645 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  568, 15,  3, 11,  1), 		 // 23714 mops, 6.3e-5 errors
+    /* 22 */ V0Parameter( 2, 10,  547, 44,  1, 10,  1), 		 // 67018 mops, 6.1e-5 errors
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  547,  1, 23,  5,  2), 		 //  636 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  1, 23, 11,  1), 		 //  981 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  514,  2, 16,  4,  2), 		 // 1431 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 1432 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 1434 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 1441 mops, 5.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 1481 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 2001 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 2029 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  3, 12,  5,  2), 		 // 2187 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  528,  3, 12,  5,  2), 		 // 2670 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 3516 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 4934 mops, 5.9e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 5012 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 6107 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 7660 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 9656 mops, 5.6e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 11226 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 15138 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 21596 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 40376 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 66778 mops, 6.1e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 // 1722 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 2212 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  517,  2, 16,  5,  2), 		 // 2225 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 2878 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 3106 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  521,  3, 12,  5,  2), 		 // 3138 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  503,  3, 12,  9,  1), 		 // 4023 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  546,  3, 12,  5,  2), 		 // 4168 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  503,  4,  9,  9,  1), 		 // 7515 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  531,  4,  9, 10,  1), 		 // 7753 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8,  9,  1), 		 // 9380 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  6,  7,  9,  1), 		 // 12717 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  7,  6, 10,  1), 		 // 14763 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  528,  9,  5, 10,  1), 		 // 18952 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  524, 14,  3, 10,  1), 		 // 28864 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522, 14,  3, 10,  1), 		 // 40559 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551, 22,  2, 10,  1), 		 // 64791 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  524, 44,  1, 10,  1), 		 // 197831 mops, 5.7e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  528,  1, 23,  5,  2), 		 // 1722 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 2207 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 2212 mops, 4.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  517,  2, 16,  5,  2), 		 // 2225 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  520,  2, 16,  5,  2), 		 // 2878 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 3106 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  521,  3, 12,  5,  2), 		 // 3138 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  503,  3, 12,  9,  1), 		 // 4023 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  546,  3, 12,  5,  2), 		 // 4168 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  533,  3, 12, 10,  1), 		 // 6031 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  503,  4,  9,  9,  1), 		 // 7515 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  531,  4,  9, 10,  1), 		 // 7753 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  521,  5,  8,  9,  1), 		 // 9380 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  512,  6,  7,  9,  1), 		 // 12717 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516,  7,  6, 10,  1), 		 // 14763 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  528,  9,  5, 10,  1), 		 // 18952 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  524, 14,  3, 10,  1), 		 // 28864 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  522, 14,  3, 10,  1), 		 // 40559 mops, 5.6e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  551, 22,  2, 10,  1), 		 // 64791 mops, 6.2e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  524, 44,  1, 10,  1), 		 // 197831 mops, 5.7e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  549,  1, 23,  5,  2), 		 // 2651 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 3311 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  4,  2), 		 // 3312 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  2, 16,  5,  2), 		 // 3318 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  522,  2, 16,  5,  2), 		 // 3358 mops, 5.7e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  527,  2, 16,  5,  2), 		 // 4352 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  514,  3, 12,  5,  2), 		 // 4671 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  530,  3, 12,  5,  2), 		 // 4755 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  507,  3, 12,  9,  1), 		 // 6062 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 7575 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  532,  3, 12, 10,  1), 		 // 10429 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  506,  4,  9,  9,  1), 		 // 11309 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  504,  5,  8,  9,  1), 		 // 13822 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  5,  8, 10,  1), 		 // 14468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  524,  6,  7, 10,  1), 		 // 19328 mops, 5.7e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  535,  7,  6, 10,  1), 		 // 22571 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  561,  8,  5, 11,  1), 		 // 33371 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  576, 14,  3, 11,  1), 		 // 45511 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  561, 14,  3, 11,  1), 		 // 63143 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  536, 22,  2, 10,  1), 		 // 142157 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  554, 45,  1, 10,  1), 		 // 311890 mops, 6.3e-5 errors
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 4473 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 4478 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  513,  2, 16,  5,  2), 		 // 4489 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  528,  2, 16,  5,  2), 		 // 4569 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  538,  2, 16,  5,  2), 		 // 5938 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  515,  3, 12,  5,  2), 		 // 6315 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  542,  3, 12,  5,  2), 		 // 6510 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  511,  3, 12,  9,  1), 		 // 8199 mops, 5.5e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  545,  3, 12, 10,  1), 		 // 10420 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  592,  3, 12, 12,  1), 		 // 14938 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  510,  4,  9,  9,  1), 		 // 15244 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  507,  5,  8,  9,  1), 		 // 18609 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  530,  5,  8, 10,  1), 		 // 22036 mops, 5.8e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  547,  6,  7, 10,  1), 		 // 26523 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  519,  8,  5, 10,  1), 		 // 33780 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  517, 11,  4, 10,  1), 		 // 45680 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  521, 11,  4, 10,  1), 		 // 64441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  559, 15,  3, 11,  1), 		 // 90214 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  519, 22,  2, 10,  1), 		 // 199194 mops, 5.9e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  556, 44,  1, 11,  1), 		 // 807482 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  510,  2, 16,  5,  2), 		 // 5968 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 5975 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  515,  2, 16,  5,  2), 		 // 6003 mops, 5.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  539,  2, 16,  5,  2), 		 // 6175 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  577,  2, 16,  5,  2), 		 // 8273 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  517,  3, 12,  5,  2), 		 // 8443 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  583,  3, 12,  6,  2), 		 // 9115 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  517,  3, 12,  9,  1), 		 // 11011 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  548,  4,  9,  5,  2), 		 // 14503 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  501,  4,  9,  9,  1), 		 // 20137 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  4,  9,  9,  1), 		 // 20463 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  511,  5,  8,  9,  1), 		 // 24924 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  567,  6,  7, 11,  1), 		 // 31279 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  509,  7,  6,  9,  1), 		 // 39284 mops, 5.6e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  533,  8,  5, 10,  1), 		 // 45682 mops, 5.9e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  528, 11,  4, 10,  1), 		 // 61582 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  539, 11,  4, 10,  1), 		 // 87441 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  535, 14,  3, 10,  1), 		 // 162821 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  533, 22,  2, 10,  1), 		 // 269126 mops, 6.1e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  511,  2, 16,  5,  2), 		 // 7600 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  516,  2, 16,  5,  2), 		 // 7645 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  562,  2, 16,  5,  2), 		 // 8063 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  512,  3, 12,  5,  2), 		 // 10646 mops, 5.4e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  519,  3, 12,  5,  2), 		 // 10731 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  502,  3, 12,  9,  1), 		 // 13703 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  535,  3, 12,  5,  2), 		 // 14050 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  575,  4,  9, 11,  1), 		 // 19118 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  502,  4,  9,  9,  1), 		 // 25428 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  523,  4,  9,  9,  1), 		 // 26003 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  516,  5,  8,  9,  1), 		 // 31572 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  509,  6,  7,  9,  1), 		 // 42799 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  512,  7,  6, 10,  1), 		 // 49610 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  587,  8,  5, 11,  1), 		 // 60569 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  550, 11,  4, 10,  1), 		 // 79059 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  516, 14,  3, 10,  1), 		 // 135475 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  531, 22,  2, 10,  1), 		 // 213514 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  564, 23,  2, 11,  1), 		 // 362490 mops, 6.3e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_pbs_2022-6-27_144

@@ -0,0 +1,547 @@
+{ /* Security level: 144 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  587,  1, 22,  4,  2), 		 //  143 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  603,  1, 22,  5,  2), 		 //  148 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  649,  1, 22,  5,  2), 		 //  227 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  610,  2, 15,  5,  2), 		 //  247 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 //  352 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 //  352 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  584,  2, 15,  4,  2), 		 //  353 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 //  356 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 //  473 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 //  497 mops, 5.6e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 //  505 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  617,  4,  9,  5,  2), 		 //  663 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  614,  3, 11,  5,  2), 		 //  849 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 1081 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 1288 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 1585 mops, 5.9e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 1938 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 2582 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 3497 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 4582 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 7049 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 15456 mops, 5.9e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 36116 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 153721 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  591,  1, 22,  5,  2), 		 //  470 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  588,  2, 15,  5,  2), 		 //  551 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 //  770 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 //  770 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  576,  2, 15,  5,  2), 		 //  771 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  580,  2, 15,  5,  2), 		 //  775 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  607,  2, 15,  5,  2), 		 //  797 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  618,  2, 15,  5,  2), 		 // 1044 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  583,  3, 11,  5,  2), 		 // 1089 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  589,  4,  9,  5,  2), 		 // 1409 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  575,  3, 11,  9,  1), 		 // 1743 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  586,  4,  9,  9,  1), 		 // 1845 mops, 5.8e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  571,  4,  9,  9,  1), 		 // 2650 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  573,  5,  8,  9,  1), 		 // 3249 mops, 5.8e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  579,  6,  7,  9,  1), 		 // 3865 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  604,  7,  6, 10,  1), 		 // 4572 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  588,  8,  5, 10,  1), 		 // 5914 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  636, 10,  4, 11,  1), 		 // 7638 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  596, 14,  3, 10,  1), 		 // 12967 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  644, 14,  3, 11,  1), 		 // 20797 mops, 6.3e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  614, 22,  2, 10,  1), 		 // 48943 mops, 6.0e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  624, 22,  2, 11,  1), 		 // 150704 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  649,  1, 22,  5,  2), 		 // 1005 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  610,  2, 15,  5,  2), 		 // 1129 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 1541 mops, 6.0e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 1542 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 1546 mops, 5.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 // 1561 mops, 5.4e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 // 2026 mops, 5.9e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 // 2169 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 // 2205 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  594,  3, 11,  5,  2), 		 // 2860 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  600,  3, 11, 10,  1), 		 // 3585 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 4614 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 5385 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 6622 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 8104 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 10795 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 14500 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 18861 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 28930 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 62876 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 146107 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 618151 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 2377 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 2377 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 2380 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  579,  2, 15,  5,  2), 		 // 2388 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  595,  2, 15,  5,  2), 		 // 2430 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  600,  2, 15,  5,  2), 		 // 3143 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  581,  3, 11,  5,  2), 		 // 3350 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  617,  3, 11,  5,  2), 		 // 3477 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  614,  3, 11,  5,  2), 		 // 4471 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  578,  4,  9,  9,  1), 		 // 5605 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  569,  4,  9,  9,  1), 		 // 8047 mops, 5.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  617,  4,  9, 10,  1), 		 // 8449 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  574,  6,  7,  9,  1), 		 // 11700 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  588,  7,  6,  9,  1), 		 // 13689 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  579,  8,  5, 10,  1), 		 // 17805 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  594, 10,  4, 10,  1), 		 // 22316 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  617, 14,  3, 10,  1), 		 // 31481 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  597, 14,  3, 10,  1), 		 // 60248 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  624, 21,  2, 11,  1), 		 // 97970 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  625, 22,  2, 10,  1), 		 // 235615 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 2377 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 2377 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 2380 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  579,  2, 15,  5,  2), 		 // 2388 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  595,  2, 15,  5,  2), 		 // 2430 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  600,  2, 15,  5,  2), 		 // 3143 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  581,  3, 11,  5,  2), 		 // 3350 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  617,  3, 11,  5,  2), 		 // 3477 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  614,  3, 11,  5,  2), 		 // 4471 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  578,  4,  9,  9,  1), 		 // 5605 mops, 5.5e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  569,  4,  9,  9,  1), 		 // 8047 mops, 5.3e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  617,  4,  9, 10,  1), 		 // 8449 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  574,  6,  7,  9,  1), 		 // 11700 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  588,  7,  6,  9,  1), 		 // 13689 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  579,  8,  5, 10,  1), 		 // 17805 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  594, 10,  4, 10,  1), 		 // 22316 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  617, 14,  3, 10,  1), 		 // 31481 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  597, 14,  3, 10,  1), 		 // 60248 mops, 5.9e-5 errors
+    /* 18 */ V0Parameter( 2, 10,  624, 21,  2, 11,  1), 		 // 97970 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  625, 22,  2, 10,  1), 		 // 235615 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  576,  2, 15,  5,  2), 		 // 3571 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  581,  2, 15,  5,  2), 		 // 3591 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  615,  2, 15,  5,  2), 		 // 3725 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  636,  2, 15,  5,  2), 		 // 4894 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  585,  3, 11,  5,  2), 		 // 5047 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  571,  3, 11,  9,  1), 		 // 6500 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  578,  3, 11,  9,  1), 		 // 8004 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  591,  4,  9,  9,  1), 		 // 8519 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  573,  4,  9,  9,  1), 		 // 12120 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  575,  5,  8,  9,  1), 		 // 14856 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  583,  6,  7,  9,  1), 		 // 17704 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  620,  7,  6, 10,  1), 		 // 21178 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  594,  8,  5, 10,  1), 		 // 27086 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  629, 11,  4, 11,  1), 		 // 37870 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  606, 14,  3, 10,  1), 		 // 59425 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  599, 14,  3, 10,  1), 		 // 96829 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  626, 22,  2, 11,  1), 		 // 223047 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  632, 43,  1, 11,  1), 		 // 689341 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  576,  2, 15,  5,  2), 		 // 3571 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  581,  2, 15,  5,  2), 		 // 3591 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  615,  2, 15,  5,  2), 		 // 3725 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  636,  2, 15,  5,  2), 		 // 4894 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  585,  3, 11,  5,  2), 		 // 5047 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  571,  3, 11,  9,  1), 		 // 6500 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  578,  3, 11,  9,  1), 		 // 8004 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  591,  4,  9,  9,  1), 		 // 8519 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  573,  4,  9,  9,  1), 		 // 12120 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  575,  5,  8,  9,  1), 		 // 14856 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  583,  6,  7,  9,  1), 		 // 17704 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  620,  7,  6, 10,  1), 		 // 21178 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  594,  8,  5, 10,  1), 		 // 27086 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  629, 11,  4, 11,  1), 		 // 37870 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  606, 14,  3, 10,  1), 		 // 59425 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  599, 14,  3, 10,  1), 		 // 96829 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  626, 22,  2, 11,  1), 		 // 223047 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  632, 43,  1, 11,  1), 		 // 689341 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  580,  2, 15,  4,  2), 		 // 3566 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  576,  2, 15,  5,  2), 		 // 3571 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  581,  2, 15,  5,  2), 		 // 3591 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  615,  2, 15,  5,  2), 		 // 3725 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  636,  2, 15,  5,  2), 		 // 4894 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  585,  3, 11,  5,  2), 		 // 5047 mops, 5.4e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  571,  3, 11,  9,  1), 		 // 6500 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  578,  3, 11,  9,  1), 		 // 8004 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  591,  4,  9,  9,  1), 		 // 8519 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  573,  4,  9,  9,  1), 		 // 12120 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  575,  5,  8,  9,  1), 		 // 14856 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  583,  6,  7,  9,  1), 		 // 17704 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  620,  7,  6, 10,  1), 		 // 21178 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  594,  8,  5, 10,  1), 		 // 27086 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  629, 11,  4, 11,  1), 		 // 37870 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  606, 14,  3, 10,  1), 		 // 59425 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 2, 10,  599, 14,  3, 10,  1), 		 // 96829 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  626, 22,  2, 11,  1), 		 // 223047 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  632, 43,  1, 11,  1), 		 // 689341 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 4827 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  577,  2, 15,  5,  2), 		 // 4833 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  583,  2, 15,  5,  2), 		 // 4865 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  585,  2, 15,  5,  2), 		 // 6255 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  578,  3, 11,  5,  2), 		 // 6770 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  589,  3, 11,  5,  2), 		 // 6849 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  575,  3, 11,  9,  1), 		 // 8792 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  586,  3, 11,  9,  1), 		 // 10851 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  609,  4,  9, 10,  1), 		 // 11713 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  578,  4,  9,  9,  1), 		 // 16354 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  581,  5,  8,  9,  1), 		 // 20062 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  593,  6,  7, 10,  1), 		 // 24025 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  599,  8,  5, 10,  1), 		 // 31602 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  640,  8,  5, 11,  1), 		 // 37922 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  586, 10,  4, 10,  1), 		 // 56549 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  587, 14,  3, 10,  1), 		 // 86551 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  629, 21,  2, 11,  1), 		 // 184547 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  635, 21,  2, 11,  1), 		 // 425625 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  641, 44,  1, 11,  1), 		 // 946763 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 4827 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  577,  2, 15,  5,  2), 		 // 4833 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  583,  2, 15,  5,  2), 		 // 4865 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  585,  2, 15,  5,  2), 		 // 6255 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  578,  3, 11,  5,  2), 		 // 6770 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  589,  3, 11,  5,  2), 		 // 6849 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  575,  3, 11,  9,  1), 		 // 8792 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  586,  3, 11,  9,  1), 		 // 10851 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  609,  4,  9, 10,  1), 		 // 11713 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  578,  4,  9,  9,  1), 		 // 16354 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  581,  5,  8,  9,  1), 		 // 20062 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  593,  6,  7, 10,  1), 		 // 24025 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  599,  8,  5, 10,  1), 		 // 31602 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  640,  8,  5, 11,  1), 		 // 37922 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  586, 10,  4, 10,  1), 		 // 56549 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  587, 14,  3, 10,  1), 		 // 86551 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  629, 21,  2, 11,  1), 		 // 184547 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  635, 21,  2, 11,  1), 		 // 425625 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  641, 44,  1, 11,  1), 		 // 946763 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 4827 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  577,  2, 15,  5,  2), 		 // 4833 mops, 5.5e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  583,  2, 15,  5,  2), 		 // 4865 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  585,  2, 15,  5,  2), 		 // 6255 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  578,  3, 11,  5,  2), 		 // 6770 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  589,  3, 11,  5,  2), 		 // 6849 mops, 5.6e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  575,  3, 11,  9,  1), 		 // 8792 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  586,  3, 11,  9,  1), 		 // 10851 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  609,  4,  9, 10,  1), 		 // 11713 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  578,  4,  9,  9,  1), 		 // 16354 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  581,  5,  8,  9,  1), 		 // 20062 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  593,  6,  7, 10,  1), 		 // 24025 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  599,  8,  5, 10,  1), 		 // 31602 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  640,  8,  5, 11,  1), 		 // 37922 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  586, 10,  4, 10,  1), 		 // 56549 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  587, 14,  3, 10,  1), 		 // 86551 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  629, 21,  2, 11,  1), 		 // 184547 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  635, 21,  2, 11,  1), 		 // 425625 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  641, 44,  1, 11,  1), 		 // 946763 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 6440 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 6455 mops, 5.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 // 6519 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 // 8381 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 // 9040 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 // 9194 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  594,  3, 11,  5,  2), 		 // 11814 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  600,  3, 11, 10,  1), 		 // 14720 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 19039 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 22008 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 27056 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 33124 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 44121 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 59036 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 76523 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 117197 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 253620 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 587734 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 2479187 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 6440 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 6455 mops, 5.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 // 6519 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 // 8381 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 // 9040 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 // 9194 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  594,  3, 11,  5,  2), 		 // 11814 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  600,  3, 11, 10,  1), 		 // 14720 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 19039 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 22008 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 27056 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 33124 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 44121 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 59036 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 76523 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 117197 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 253620 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 587734 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 2479187 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 6440 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 6455 mops, 5.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 // 6519 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 // 8381 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 // 9040 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 // 9194 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  594,  3, 11,  5,  2), 		 // 11814 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  600,  3, 11, 10,  1), 		 // 14720 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 19039 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 22008 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 27056 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 33124 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 44121 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 59036 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 76523 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 117197 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 253620 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 587734 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 2479187 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  581,  2, 15,  4,  2), 		 // 6440 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 6455 mops, 5.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  587,  2, 15,  5,  2), 		 // 6519 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  589,  2, 15,  5,  2), 		 // 8381 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  579,  3, 11,  5,  2), 		 // 9040 mops, 5.6e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  595,  3, 11,  5,  2), 		 // 9194 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  594,  3, 11,  5,  2), 		 // 11814 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  600,  3, 11, 10,  1), 		 // 14720 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 19039 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  587,  4,  9,  9,  1), 		 // 22008 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  591,  5,  8, 10,  1), 		 // 27056 mops, 5.9e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  627,  6,  7, 11,  1), 		 // 33124 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  648,  8,  5, 11,  1), 		 // 44121 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  579, 10,  4, 10,  1), 		 // 59036 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  602, 10,  4, 10,  1), 		 // 76523 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  604, 14,  3, 10,  1), 		 // 117197 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 2, 10,  587, 21,  2, 10,  1), 		 // 253620 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  616, 22,  2, 10,  1), 		 // 587734 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  623, 44,  1, 11,  1), 		 // 2479187 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  578,  2, 15,  5,  2), 		 // 8208 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  590,  2, 15,  5,  2), 		 // 8317 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  594,  2, 15,  5,  2), 		 // 10692 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  580,  3, 11,  5,  2), 		 // 11475 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  604,  3, 11,  5,  2), 		 // 11768 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  589,  3, 11, 10,  1), 		 // 15107 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  574,  4,  9,  9,  1), 		 // 19008 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  671,  5,  8, 11,  1), 		 // 25573 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  597,  4,  9, 10,  1), 		 // 28077 mops, 5.9e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  608,  5,  8, 10,  1), 		 // 34653 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  582,  7,  6,  9,  1), 		 // 46005 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  576,  8,  5,  9,  1), 		 // 59851 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  586, 10,  4, 10,  1), 		 // 74690 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  597, 14,  3, 10,  1), 		 // 104187 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 2, 10,  587, 14,  3, 10,  1), 		 // 200294 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 2, 10,  599, 21,  2, 10,  1), 		 // 321251 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  674, 22,  2, 12,  1), 		 // 760560 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  667, 45,  1, 12,  1), 		 // 3349657 mops, 6.3e-5 errors
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_pbs_2022-6-27_160

@@ -0,0 +1,547 @@
+{ /* Security level: 160 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  691,  1, 19,  5,  2), 		 //  237 mops, 6.3e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  648,  2, 15,  4,  2), 		 //  254 mops, 6.0e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  658,  2, 15,  4,  2), 		 //  256 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  700,  2, 15,  5,  2), 		 //  269 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  657,  2, 15,  5,  2), 		 //  382 mops, 5.5e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 //  527 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 //  529 mops, 5.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 //  538 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  646,  4,  8,  5,  2), 		 //  681 mops, 5.5e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 //  699 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 //  953 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 1218 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 1524 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 2273 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 2852 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 3505 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 4191 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 5632 mops, 5.7e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 6451 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 8771 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 12139 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 23752 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 37679 mops, 6.3e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 161443 mops, 6.2e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  651,  2, 15,  4,  2), 		 //  584 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  658,  2, 15,  5,  2), 		 //  594 mops, 5.8e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  647,  2, 15,  5,  2), 		 //  831 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  694,  2, 15,  5,  2), 		 //  870 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  642,  3, 11,  5,  2), 		 // 1155 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  650,  3, 11,  5,  2), 		 // 1164 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  628,  4,  8,  9,  1), 		 // 1483 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  653,  4,  8,  5,  2), 		 // 1499 mops, 5.7e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  644,  4,  8,  9,  1), 		 // 1951 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  664,  6,  6, 10,  1), 		 // 2210 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  651,  6,  6, 10,  1), 		 // 2834 mops, 6.2e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  720,  6,  6, 11,  1), 		 // 3707 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 2, 10,  659,  7,  5, 10,  1), 		 // 5562 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  674,  4,  9, 10,  1), 		 // 5967 mops, 6.1e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  661,  5,  8, 10,  1), 		 // 7287 mops, 5.6e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  725,  6,  7, 11,  1), 		 // 8999 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  666,  7,  6, 10,  1), 		 // 11665 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  683,  9,  5, 10,  1), 		 // 15000 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 22782 mops, 5.8e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  668, 14,  3, 10,  1), 		 // 32359 mops, 6.0e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  692, 22,  2, 11,  1), 		 // 51142 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  713, 22,  2, 11,  1), 		 // 158184 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  648,  2, 15,  5,  2), 		 // 1175 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  700,  2, 15,  5,  2), 		 // 1239 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  657,  2, 15,  5,  2), 		 // 1679 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 // 2308 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 // 2317 mops, 5.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 // 2358 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  631,  4,  8,  9,  1), 		 // 2976 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 // 3064 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 // 4083 mops, 6.2e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 5328 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 6512 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 9507 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 11770 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 14460 mops, 5.7e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 17233 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 23121 mops, 5.7e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 26486 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 35997 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 49852 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 96154 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 152567 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 649523 mops, 6.2e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  645,  2, 15,  5,  2), 		 // 2562 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  670,  2, 15,  5,  2), 		 // 2628 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  642,  3, 11,  5,  2), 		 // 3566 mops, 5.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  647,  3, 11,  5,  2), 		 // 3583 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  689,  3, 11,  5,  2), 		 // 3732 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  635,  4,  8,  9,  1), 		 // 4606 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  638,  4,  8,  9,  1), 		 // 5948 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  651,  6,  6,  9,  1), 		 // 6718 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  643,  6,  6,  9,  1), 		 // 8606 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  670,  7,  5, 10,  1), 		 // 10184 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  668,  7,  5, 10,  1), 		 // 14743 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  662,  4,  9, 10,  1), 		 // 17952 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  654,  5,  8, 10,  1), 		 // 21986 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  679,  6,  7, 10,  1), 		 // 26516 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  657,  7,  6, 10,  1), 		 // 35106 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  694,  8,  5, 10,  1), 		 // 40786 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  685, 11,  4, 10,  1), 		 // 55186 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  658, 14,  3, 10,  1), 		 // 97098 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  689, 14,  3, 10,  1), 		 // 146922 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  722, 22,  2, 11,  1), 		 // 248595 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  645,  2, 15,  5,  2), 		 // 2562 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  670,  2, 15,  5,  2), 		 // 2628 mops, 5.9e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  642,  3, 11,  5,  2), 		 // 3566 mops, 5.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  647,  3, 11,  5,  2), 		 // 3583 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  689,  3, 11,  5,  2), 		 // 3732 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  635,  4,  8,  9,  1), 		 // 4606 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  638,  4,  8,  9,  1), 		 // 5948 mops, 5.8e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  651,  6,  6,  9,  1), 		 // 6718 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  643,  6,  6,  9,  1), 		 // 8606 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  670,  7,  5, 10,  1), 		 // 10184 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  668,  7,  5, 10,  1), 		 // 14743 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  662,  4,  9, 10,  1), 		 // 17952 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  654,  5,  8, 10,  1), 		 // 21986 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  679,  6,  7, 10,  1), 		 // 26516 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  657,  7,  6, 10,  1), 		 // 35106 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  694,  8,  5, 10,  1), 		 // 40786 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  685, 11,  4, 10,  1), 		 // 55186 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  658, 14,  3, 10,  1), 		 // 97098 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  689, 14,  3, 10,  1), 		 // 146922 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  722, 22,  2, 11,  1), 		 // 248595 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  648,  2, 15,  5,  2), 		 // 3855 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  728,  2, 15,  5,  2), 		 // 4171 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 5354 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  651,  3, 11,  5,  2), 		 // 5397 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  629,  4,  8,  9,  1), 		 // 6868 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  641,  4,  8,  9,  1), 		 // 6950 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  647,  4,  8,  9,  1), 		 // 8999 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  675,  6,  6, 10,  1), 		 // 10329 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  657,  6,  6, 10,  1), 		 // 13100 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  657,  7,  5, 10,  1), 		 // 18498 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  667,  7,  5, 10,  1), 		 // 25526 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  683,  4,  9, 10,  1), 		 // 27289 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  664,  5,  8, 10,  1), 		 // 33187 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  6,  7, 10,  1), 		 // 45659 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  672,  7,  6, 10,  1), 		 // 53136 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  698,  9,  5, 11,  1), 		 // 68720 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  667, 14,  3, 10,  1), 		 // 103621 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  674, 14,  3, 10,  1), 		 // 146982 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  719, 22,  2, 11,  1), 		 // 234994 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  682, 44,  1, 10,  1), 		 // 724920 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  648,  2, 15,  5,  2), 		 // 3855 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  728,  2, 15,  5,  2), 		 // 4171 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 5354 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  651,  3, 11,  5,  2), 		 // 5397 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  629,  4,  8,  9,  1), 		 // 6868 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  641,  4,  8,  9,  1), 		 // 6950 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  647,  4,  8,  9,  1), 		 // 8999 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  675,  6,  6, 10,  1), 		 // 10329 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  657,  6,  6, 10,  1), 		 // 13100 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  657,  7,  5, 10,  1), 		 // 18498 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  667,  7,  5, 10,  1), 		 // 25526 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  683,  4,  9, 10,  1), 		 // 27289 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  664,  5,  8, 10,  1), 		 // 33187 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  6,  7, 10,  1), 		 // 45659 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  672,  7,  6, 10,  1), 		 // 53136 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  698,  9,  5, 11,  1), 		 // 68720 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  667, 14,  3, 10,  1), 		 // 103621 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  674, 14,  3, 10,  1), 		 // 146982 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  719, 22,  2, 11,  1), 		 // 234994 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  682, 44,  1, 10,  1), 		 // 724920 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  648,  2, 15,  5,  2), 		 // 3855 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  728,  2, 15,  5,  2), 		 // 4171 mops, 6.3e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 5354 mops, 5.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  651,  3, 11,  5,  2), 		 // 5397 mops, 5.8e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  629,  4,  8,  9,  1), 		 // 6868 mops, 5.3e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  641,  4,  8,  9,  1), 		 // 6950 mops, 6.0e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  647,  4,  8,  9,  1), 		 // 8999 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  675,  6,  6, 10,  1), 		 // 10329 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  657,  6,  6, 10,  1), 		 // 13100 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 2, 10,  657,  7,  5, 10,  1), 		 // 18498 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 2, 10,  667,  7,  5, 10,  1), 		 // 25526 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  683,  4,  9, 10,  1), 		 // 27289 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  664,  5,  8, 10,  1), 		 // 33187 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  6,  7, 10,  1), 		 // 45659 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  672,  7,  6, 10,  1), 		 // 53136 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  698,  9,  5, 11,  1), 		 // 68720 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  667, 14,  3, 10,  1), 		 // 103621 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  674, 14,  3, 10,  1), 		 // 146982 mops, 6.2e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  719, 22,  2, 11,  1), 		 // 234994 mops, 6.3e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  682, 44,  1, 10,  1), 		 // 724920 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  686,  2, 15,  5,  2), 		 // 6936 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 7239 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  656,  3, 11,  5,  2), 		 // 7333 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  630,  4,  8,  9,  1), 		 // 9291 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  662,  4,  8,  5,  2), 		 // 9463 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  660,  4,  8,  9,  1), 		 // 12276 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  683,  4,  8, 10,  1), 		 // 15338 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  683,  6,  6, 10,  1), 		 // 18075 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  683,  7,  5, 10,  1), 		 // 25460 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  650,  4,  9,  9,  1), 		 // 35764 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  647,  5,  8,  9,  1), 		 // 43952 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  680,  5,  8, 10,  1), 		 // 44919 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  680,  6,  7, 10,  1), 		 // 61739 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  702,  7,  6, 11,  1), 		 // 72487 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  680,  8,  5, 10,  1), 		 // 103435 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  687, 14,  3, 10,  1), 		 // 140357 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  711, 14,  3, 11,  1), 		 // 200755 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  670, 22,  2, 10,  1), 		 // 454415 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  740, 45,  1, 12,  1), 		 // 1021595 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  686,  2, 15,  5,  2), 		 // 6936 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 7239 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  656,  3, 11,  5,  2), 		 // 7333 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  630,  4,  8,  9,  1), 		 // 9291 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  662,  4,  8,  5,  2), 		 // 9463 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  660,  4,  8,  9,  1), 		 // 12276 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  683,  4,  8, 10,  1), 		 // 15338 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  683,  6,  6, 10,  1), 		 // 18075 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  683,  7,  5, 10,  1), 		 // 25460 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  650,  4,  9,  9,  1), 		 // 35764 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  647,  5,  8,  9,  1), 		 // 43952 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  680,  5,  8, 10,  1), 		 // 44919 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  680,  6,  7, 10,  1), 		 // 61739 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  702,  7,  6, 11,  1), 		 // 72487 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  680,  8,  5, 10,  1), 		 // 103435 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  687, 14,  3, 10,  1), 		 // 140357 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  711, 14,  3, 11,  1), 		 // 200755 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  670, 22,  2, 10,  1), 		 // 454415 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  740, 45,  1, 12,  1), 		 // 1021595 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  686,  2, 15,  5,  2), 		 // 6936 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  643,  3, 11,  5,  2), 		 // 7239 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  656,  3, 11,  5,  2), 		 // 7333 mops, 5.5e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  630,  4,  8,  9,  1), 		 // 9291 mops, 5.5e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  662,  4,  8,  5,  2), 		 // 9463 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  660,  4,  8,  9,  1), 		 // 12276 mops, 6.3e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  683,  4,  8, 10,  1), 		 // 15338 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  683,  6,  6, 10,  1), 		 // 18075 mops, 6.2e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  683,  7,  5, 10,  1), 		 // 25460 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  650,  4,  9,  9,  1), 		 // 35764 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  647,  5,  8,  9,  1), 		 // 43952 mops, 6.0e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  680,  5,  8, 10,  1), 		 // 44919 mops, 6.0e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  680,  6,  7, 10,  1), 		 // 61739 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  702,  7,  6, 11,  1), 		 // 72487 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  680,  8,  5, 10,  1), 		 // 103435 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  687, 14,  3, 10,  1), 		 // 140357 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  711, 14,  3, 11,  1), 		 // 200755 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  670, 22,  2, 10,  1), 		 // 454415 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  740, 45,  1, 12,  1), 		 // 1021595 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 // 9637 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 // 9675 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 // 9849 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  631,  4,  8,  9,  1), 		 // 12404 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 // 12790 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 // 16881 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 22228 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 26884 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 38864 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 47819 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 58724 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 69876 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 93678 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 107317 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 145822 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 202009 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 386930 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 613989 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 2605640 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 // 9637 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 // 9675 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 // 9849 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  631,  4,  8,  9,  1), 		 // 12404 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 // 12790 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 // 16881 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 22228 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 26884 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 38864 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 47819 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 58724 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 69876 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 93678 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 107317 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 145822 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 202009 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 386930 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 613989 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 2605640 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 // 9637 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 // 9675 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 // 9849 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  631,  4,  8,  9,  1), 		 // 12404 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 // 12790 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 // 16881 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 22228 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 26884 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 38864 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 47819 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 58724 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 69876 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 93678 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 107317 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 145822 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 202009 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 386930 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 613989 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 2605640 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  641,  3, 11,  5,  2), 		 // 9637 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  645,  3, 11,  5,  2), 		 // 9675 mops, 5.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  663,  3, 11,  5,  2), 		 // 9849 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  631,  4,  8,  9,  1), 		 // 12404 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  676,  4,  8,  5,  2), 		 // 12790 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  690,  4,  8, 10,  1), 		 // 16881 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  713,  7,  5, 11,  1), 		 // 22228 mops, 6.3e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  649,  7,  5,  9,  1), 		 // 26884 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 2, 10,  648,  7,  5,  9,  1), 		 // 38864 mops, 6.0e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  654,  4,  9,  9,  1), 		 // 47819 mops, 6.2e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  650,  5,  8,  9,  1), 		 // 58724 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  693,  5,  8, 10,  1), 		 // 69876 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  652,  7,  6,  9,  1), 		 // 93678 mops, 5.7e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  664,  8,  5, 10,  1), 		 // 107317 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  662, 11,  4, 10,  1), 		 // 145822 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  702, 15,  3, 11,  1), 		 // 202009 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  663, 14,  3, 10,  1), 		 // 386930 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  694, 22,  2, 10,  1), 		 // 613989 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  715, 44,  1, 11,  1), 		 // 2605640 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  646,  3, 11,  5,  2), 		 // 12280 mops, 5.4e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  673,  3, 11,  5,  2), 		 // 12609 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  633,  4,  8,  9,  1), 		 // 15734 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  704,  4,  8,  5,  2), 		 // 16622 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  645,  6,  6,  9,  1), 		 // 22824 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  639,  6,  6,  9,  1), 		 // 29154 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  657,  7,  5, 10,  1), 		 // 34207 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 2, 10,  656,  7,  5, 10,  1), 		 // 49322 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  657,  4,  9, 10,  1), 		 // 60334 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  651,  5,  8, 10,  1), 		 // 73932 mops, 6.3e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  668,  6,  7, 10,  1), 		 // 88696 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  654,  7,  6, 10,  1), 		 // 117827 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  675,  8,  5, 10,  1), 		 // 135591 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  671, 11,  4, 10,  1), 		 // 183921 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  695, 11,  4, 11,  1), 		 // 262908 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  673, 14,  3, 10,  1), 		 // 487408 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  685, 22,  2, 10,  1), 		 // 815020 mops, 6.1e-5 errors
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}

compilers/concrete-optimizer/v0-parameters/old_ref/wop_pbs_2022-6-27_176

@@ -0,0 +1,547 @@
+{ /* Security level: 176 */
+{ /* 6.3e-5 errors */
+{ /* precision  1 */
+    /*  0 */ V0Parameter( 2, 10,  700,  2, 12,  4,  2), 		 //  267 mops, 6.1e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  705,  2, 12,  4,  2), 		 //  268 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  711,  2, 12,  5,  2), 		 //  272 mops, 5.7e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  737,  3,  9,  5,  2), 		 //  387 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  729,  2, 12,  5,  2), 		 //  539 mops, 5.9e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 //  561 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 2, 10,  708,  4,  8,  5,  2), 		 //  719 mops, 5.5e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 //  802 mops, 5.8e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 1064 mops, 5.6e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  713,  3, 12,  5,  2), 		 // 1137 mops, 5.4e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 1150 mops, 5.7e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 1519 mops, 5.7e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 1916 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 2705 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 2948 mops, 6.1e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 3617 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 4330 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 5809 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 6666 mops, 6.0e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 9054 mops, 5.8e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 12641 mops, 6.2e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 24506 mops, 6.1e-5 errors
+    /* 22 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 39046 mops, 6.1e-5 errors
+    /* 23 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 171010 mops, 6.3e-5 errors
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  2 */
+    /*  0 */ V0Parameter( 2, 10,  701,  2, 12,  5,  2), 		 //  620 mops, 5.6e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  751,  2, 12,  5,  2), 		 //  650 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  746,  2, 12,  5,  2), 		 //  914 mops, 6.1e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  701,  3,  9,  5,  2), 		 // 1221 mops, 6.0e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  768,  3,  9,  5,  2), 		 // 1297 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 2, 10,  735,  4,  8,  5,  2), 		 // 1615 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  764,  2, 15,  5,  2), 		 // 1766 mops, 6.1e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  787,  2, 15,  5,  2), 		 // 2333 mops, 6.3e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  718,  3, 12,  5,  2), 		 // 2438 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  715,  3, 12,  5,  2), 		 // 3178 mops, 5.9e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  755,  3, 12,  5,  2), 		 // 3260 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  744,  4,  9,  5,  2), 		 // 4206 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  701,  4,  9,  9,  1), 		 // 6059 mops, 5.6e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  736,  4,  9, 10,  1), 		 // 6198 mops, 6.2e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  717,  5,  8, 10,  1), 		 // 7538 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  819,  6,  7, 12,  1), 		 // 9503 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  725,  7,  6, 10,  1), 		 // 12073 mops, 6.3e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  750,  9,  5, 10,  1), 		 // 15581 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  720, 14,  3, 10,  1), 		 // 23527 mops, 6.1e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  728, 14,  3, 10,  1), 		 // 33454 mops, 5.9e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 53110 mops, 6.3e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  735, 44,  1, 10,  1), 		 // 165088 mops, 6.1e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  3 */
+    /*  0 */ V0Parameter( 2, 10,  711,  2, 12,  5,  2), 		 // 1252 mops, 5.7e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  710,  2, 12,  5,  2), 		 // 1768 mops, 5.6e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  729,  2, 12,  5,  2), 		 // 2325 mops, 5.9e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 // 2468 mops, 5.9e-5 errors
+    /*  4 */ V0Parameter( 2, 10,  692,  4,  8,  9,  1), 		 // 3152 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 // 3442 mops, 5.8e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 4493 mops, 5.6e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  713,  3, 12,  5,  2), 		 // 4861 mops, 5.4e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 4921 mops, 5.7e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 6394 mops, 5.7e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 7991 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 11150 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 12186 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 14943 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 17887 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 23880 mops, 6.1e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 27406 mops, 6.0e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 37207 mops, 5.8e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 52001 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 99272 mops, 6.1e-5 errors
+    /* 20 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 158216 mops, 6.1e-5 errors
+    /* 21 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 688244 mops, 6.3e-5 errors
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  4 */
+    /*  0 */ V0Parameter( 2, 10,  723,  2, 12,  5,  2), 		 // 2767 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  699,  3,  9,  5,  2), 		 // 3767 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  728,  3,  9,  5,  2), 		 // 3870 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  718,  4,  8,  5,  2), 		 // 4914 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  740,  2, 15,  5,  2), 		 // 5332 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  746,  2, 15,  5,  2), 		 // 6935 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  715,  3, 12,  5,  2), 		 // 7457 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  755,  3, 12,  5,  2), 		 // 7657 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  736,  3, 12,  5,  2), 		 // 9825 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  731,  4,  9,  5,  2), 		 // 12722 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  699,  4,  9,  9,  1), 		 // 18351 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  719,  4,  9, 10,  1), 		 // 18604 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  710,  5,  8, 10,  1), 		 // 22759 mops, 5.5e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  738,  6,  7, 10,  1), 		 // 27468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  714,  7,  6, 10,  1), 		 // 36314 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  769,  8,  5, 11,  1), 		 // 42605 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  751, 11,  4, 11,  1), 		 // 57323 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  715, 14,  3, 10,  1), 		 // 100268 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  757, 14,  3, 11,  1), 		 // 152491 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  763, 44,  1, 11,  1), 		 // 473549 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  5 */
+    /*  0 */ V0Parameter( 2, 10,  723,  2, 12,  5,  2), 		 // 2767 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  699,  3,  9,  5,  2), 		 // 3767 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  728,  3,  9,  5,  2), 		 // 3870 mops, 6.3e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  718,  4,  8,  5,  2), 		 // 4914 mops, 6.2e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  740,  2, 15,  5,  2), 		 // 5332 mops, 6.0e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  746,  2, 15,  5,  2), 		 // 6935 mops, 6.2e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  715,  3, 12,  5,  2), 		 // 7457 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  755,  3, 12,  5,  2), 		 // 7657 mops, 6.0e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  736,  3, 12,  5,  2), 		 // 9825 mops, 5.8e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  731,  4,  9,  5,  2), 		 // 12722 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  699,  4,  9,  9,  1), 		 // 18351 mops, 5.5e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  719,  4,  9, 10,  1), 		 // 18604 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  710,  5,  8, 10,  1), 		 // 22759 mops, 5.5e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  738,  6,  7, 10,  1), 		 // 27468 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  714,  7,  6, 10,  1), 		 // 36314 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  769,  8,  5, 11,  1), 		 // 42605 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  751, 11,  4, 11,  1), 		 // 57323 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  715, 14,  3, 10,  1), 		 // 100268 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  757, 14,  3, 11,  1), 		 // 152491 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  763, 44,  1, 11,  1), 		 // 473549 mops, 6.2e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  6 */
+    /*  0 */ V0Parameter( 2, 10,  773,  2, 12,  5,  2), 		 // 4348 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  702,  3,  9,  5,  2), 		 // 5667 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  685,  4,  8,  9,  1), 		 // 7249 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  748,  4,  8,  5,  2), 		 // 7572 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  789,  2, 15,  5,  2), 		 // 8269 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  711,  3, 12,  5,  2), 		 // 11156 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 11216 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  716,  3, 12,  5,  2), 		 // 14549 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  772,  3, 12,  5,  2), 		 // 15078 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  753,  4,  9,  5,  2), 		 // 19345 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  702,  4,  9,  9,  1), 		 // 27578 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  751,  4,  9, 10,  1), 		 // 28456 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  722,  5,  8, 10,  1), 		 // 34386 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  6,  7, 10,  1), 		 // 47296 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  733,  7,  6, 10,  1), 		 // 55075 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  781,  9,  5, 11,  1), 		 // 72034 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  726, 14,  3, 10,  1), 		 // 107167 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  736, 14,  3, 10,  1), 		 // 152153 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  742, 21,  2, 10,  1), 		 // 337848 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  748, 44,  1, 10,  1), 		 // 750903 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  7 */
+    /*  0 */ V0Parameter( 2, 10,  773,  2, 12,  5,  2), 		 // 4348 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  702,  3,  9,  5,  2), 		 // 5667 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  685,  4,  8,  9,  1), 		 // 7249 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  748,  4,  8,  5,  2), 		 // 7572 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  789,  2, 15,  5,  2), 		 // 8269 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  711,  3, 12,  5,  2), 		 // 11156 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 11216 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  716,  3, 12,  5,  2), 		 // 14549 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  772,  3, 12,  5,  2), 		 // 15078 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  753,  4,  9,  5,  2), 		 // 19345 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  702,  4,  9,  9,  1), 		 // 27578 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  751,  4,  9, 10,  1), 		 // 28456 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  722,  5,  8, 10,  1), 		 // 34386 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  6,  7, 10,  1), 		 // 47296 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  733,  7,  6, 10,  1), 		 // 55075 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  781,  9,  5, 11,  1), 		 // 72034 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  726, 14,  3, 10,  1), 		 // 107167 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  736, 14,  3, 10,  1), 		 // 152153 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  742, 21,  2, 10,  1), 		 // 337848 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  748, 44,  1, 10,  1), 		 // 750903 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  8 */
+    /*  0 */ V0Parameter( 2, 10,  773,  2, 12,  5,  2), 		 // 4348 mops, 6.2e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  702,  3,  9,  5,  2), 		 // 5667 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 2, 10,  685,  4,  8,  9,  1), 		 // 7249 mops, 5.6e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  748,  4,  8,  5,  2), 		 // 7572 mops, 6.1e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  789,  2, 15,  5,  2), 		 // 8269 mops, 6.3e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  711,  3, 12,  5,  2), 		 // 11156 mops, 5.3e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 11216 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  716,  3, 12,  5,  2), 		 // 14549 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  772,  3, 12,  5,  2), 		 // 15078 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  753,  4,  9,  5,  2), 		 // 19345 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  702,  4,  9,  9,  1), 		 // 27578 mops, 5.6e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  751,  4,  9, 10,  1), 		 // 28456 mops, 6.1e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  722,  5,  8, 10,  1), 		 // 34386 mops, 6.0e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  6,  7, 10,  1), 		 // 47296 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  733,  7,  6, 10,  1), 		 // 55075 mops, 6.2e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  781,  9,  5, 11,  1), 		 // 72034 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  726, 14,  3, 10,  1), 		 // 107167 mops, 5.9e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  736, 14,  3, 10,  1), 		 // 152153 mops, 6.3e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  742, 21,  2, 10,  1), 		 // 337848 mops, 6.2e-5 errors
+    /* 19 */ V0Parameter( 3, 10,  748, 44,  1, 10,  1), 		 // 750903 mops, 6.3e-5 errors
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision  9 */
+    /*  0 */ V0Parameter( 2, 10,  706,  3,  9,  5,  2), 		 // 7694 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  688,  4,  8,  9,  1), 		 // 9828 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  721,  2, 15,  5,  2), 		 // 10638 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  785,  5,  6, 11,  1), 		 // 13113 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  697,  3, 12,  9,  1), 		 // 15085 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 15163 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 19594 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  731,  3, 12,  5,  2), 		 // 24260 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  809,  4,  9,  6,  2), 		 // 26964 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  705,  4,  9,  9,  1), 		 // 37034 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  701,  5,  8,  9,  1), 		 // 45455 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  742,  5,  8, 10,  1), 		 // 46649 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  745,  6,  7, 10,  1), 		 // 64170 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  802,  7,  6, 12,  1), 		 // 76835 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  743,  8,  5, 10,  1), 		 // 107251 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  752, 14,  3, 11,  1), 		 // 145675 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  742, 15,  3, 10,  1), 		 // 218432 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  729, 22,  2, 10,  1), 		 // 469310 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  759, 44,  1, 11,  1), 		 // 1937642 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 10 */
+    /*  0 */ V0Parameter( 2, 10,  706,  3,  9,  5,  2), 		 // 7694 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  688,  4,  8,  9,  1), 		 // 9828 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  721,  2, 15,  5,  2), 		 // 10638 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  785,  5,  6, 11,  1), 		 // 13113 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  697,  3, 12,  9,  1), 		 // 15085 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 15163 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 19594 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  731,  3, 12,  5,  2), 		 // 24260 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  809,  4,  9,  6,  2), 		 // 26964 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  705,  4,  9,  9,  1), 		 // 37034 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  701,  5,  8,  9,  1), 		 // 45455 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  742,  5,  8, 10,  1), 		 // 46649 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  745,  6,  7, 10,  1), 		 // 64170 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  802,  7,  6, 12,  1), 		 // 76835 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  743,  8,  5, 10,  1), 		 // 107251 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  752, 14,  3, 11,  1), 		 // 145675 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  742, 15,  3, 10,  1), 		 // 218432 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  729, 22,  2, 10,  1), 		 // 469310 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  759, 44,  1, 11,  1), 		 // 1937642 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 11 */
+    /*  0 */ V0Parameter( 2, 10,  706,  3,  9,  5,  2), 		 // 7694 mops, 6.0e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  688,  4,  8,  9,  1), 		 // 9828 mops, 5.7e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  721,  2, 15,  5,  2), 		 // 10638 mops, 5.4e-5 errors
+    /*  3 */ V0Parameter( 2, 10,  785,  5,  6, 11,  1), 		 // 13113 mops, 6.3e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  697,  3, 12,  9,  1), 		 // 15085 mops, 5.8e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 15163 mops, 5.9e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  719,  3, 12,  5,  2), 		 // 19594 mops, 6.0e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  731,  3, 12,  5,  2), 		 // 24260 mops, 5.9e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  809,  4,  9,  6,  2), 		 // 26964 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  705,  4,  9,  9,  1), 		 // 37034 mops, 6.0e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  701,  5,  8,  9,  1), 		 // 45455 mops, 6.1e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  742,  5,  8, 10,  1), 		 // 46649 mops, 6.3e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  745,  6,  7, 10,  1), 		 // 64170 mops, 6.2e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  802,  7,  6, 12,  1), 		 // 76835 mops, 6.3e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  743,  8,  5, 10,  1), 		 // 107251 mops, 6.0e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  752, 14,  3, 11,  1), 		 // 145675 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  742, 15,  3, 10,  1), 		 // 218432 mops, 6.2e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  729, 22,  2, 10,  1), 		 // 469310 mops, 6.0e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  759, 44,  1, 11,  1), 		 // 1937642 mops, 6.2e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 12 */
+    /*  0 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 // 10321 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  692,  4,  8,  9,  1), 		 // 13157 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 // 14241 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 18447 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  698,  3, 12,  9,  1), 		 // 20133 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 20333 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 26218 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 32624 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 45269 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 49543 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 60729 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 72688 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 96815 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 111117 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 150821 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 210891 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 399602 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 636950 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 2761433 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 13 */
+    /*  0 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 // 10321 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  692,  4,  8,  9,  1), 		 // 13157 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 // 14241 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 18447 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  698,  3, 12,  9,  1), 		 // 20133 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 20333 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 26218 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 32624 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 45269 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 49543 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 60729 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 72688 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 96815 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 111117 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 150821 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 210891 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 399602 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 636950 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 2761433 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 14 */
+    /*  0 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 // 10321 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  692,  4,  8,  9,  1), 		 // 13157 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 // 14241 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 18447 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  698,  3, 12,  9,  1), 		 // 20133 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 20333 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 26218 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 32624 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 45269 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 49543 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 60729 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 72688 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 96815 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 111117 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 150821 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 210891 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 399602 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 636950 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 2761433 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 15 */
+    /*  0 */ V0Parameter( 2, 10,  712,  3,  9,  5,  2), 		 // 10321 mops, 5.9e-5 errors
+    /*  1 */ V0Parameter( 2, 10,  692,  4,  8,  9,  1), 		 // 13157 mops, 6.2e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  726,  2, 15,  5,  2), 		 // 14241 mops, 5.8e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  729,  2, 15,  5,  2), 		 // 18447 mops, 5.6e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  698,  3, 12,  9,  1), 		 // 20133 mops, 6.2e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  732,  3, 12,  5,  2), 		 // 20333 mops, 5.7e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  724,  3, 12,  5,  2), 		 // 26218 mops, 5.7e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  744,  3, 12,  5,  2), 		 // 32624 mops, 6.1e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  750,  3, 12, 10,  1), 		 // 45269 mops, 6.3e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  710,  4,  9,  9,  1), 		 // 49543 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  704,  5,  8,  9,  1), 		 // 60729 mops, 6.3e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  716,  6,  7, 10,  1), 		 // 72688 mops, 6.2e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  707,  7,  6,  9,  1), 		 // 96815 mops, 6.1e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  723,  8,  5, 10,  1), 		 // 111117 mops, 6.0e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  720, 11,  4, 10,  1), 		 // 150821 mops, 5.8e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  779, 15,  3, 11,  1), 		 // 210891 mops, 6.2e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  721, 14,  3, 10,  1), 		 // 399602 mops, 6.1e-5 errors
+    /* 17 */ V0Parameter( 3, 10,  762, 22,  2, 11,  1), 		 // 636950 mops, 6.1e-5 errors
+    /* 18 */ V0Parameter( 3, 10,  784, 45,  1, 11,  1), 		 // 2761433 mops, 6.3e-5 errors
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+{ /* precision 16 */
+    /*  0 */ V0Parameter( 2, 10,  698,  4,  8,  9,  1), 		 // 16749 mops, 5.8e-5 errors
+    /*  1 */ V0Parameter( 3, 10,  732,  2, 15,  5,  2), 		 // 18097 mops, 6.1e-5 errors
+    /*  2 */ V0Parameter( 3, 10,  736,  2, 15,  5,  2), 		 // 23417 mops, 6.2e-5 errors
+    /*  3 */ V0Parameter( 3, 10,  714,  3, 12,  5,  2), 		 // 25369 mops, 5.7e-5 errors
+    /*  4 */ V0Parameter( 3, 10,  741,  3, 12,  5,  2), 		 // 25833 mops, 6.1e-5 errors
+    /*  5 */ V0Parameter( 3, 10,  729,  3, 12,  5,  2), 		 // 33169 mops, 6.1e-5 errors
+    /*  6 */ V0Parameter( 3, 10,  766,  3, 12,  5,  2), 		 // 41671 mops, 6.2e-5 errors
+    /*  7 */ V0Parameter( 3, 10,  698,  4,  9,  9,  1), 		 // 61846 mops, 5.6e-5 errors
+    /*  8 */ V0Parameter( 3, 10,  713,  4,  9, 10,  1), 		 // 62512 mops, 6.1e-5 errors
+    /*  9 */ V0Parameter( 3, 10,  706,  5,  8, 10,  1), 		 // 76510 mops, 6.1e-5 errors
+    /* 10 */ V0Parameter( 3, 10,  726,  6,  7, 10,  1), 		 // 91876 mops, 5.8e-5 errors
+    /* 11 */ V0Parameter( 3, 10,  710,  7,  6, 10,  1), 		 // 121851 mops, 5.6e-5 errors
+    /* 12 */ V0Parameter( 3, 10,  738,  8,  5, 10,  1), 		 // 140694 mops, 6.3e-5 errors
+    /* 13 */ V0Parameter( 3, 10,  732, 11,  4, 10,  1), 		 // 190535 mops, 5.9e-5 errors
+    /* 14 */ V0Parameter( 3, 10,  772, 11,  4, 11,  1), 		 // 274442 mops, 6.3e-5 errors
+    /* 15 */ V0Parameter( 3, 10,  734, 14,  3, 10,  1), 		 // 504120 mops, 6.3e-5 errors
+    /* 16 */ V0Parameter( 3, 10,  752, 22,  2, 11,  1), 		 // 845173 mops, 6.3e-5 errors
+    /* 17 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 18 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 19 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 20 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 21 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 22 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 23 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 24 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 25 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 26 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 27 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 28 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 29 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 30 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+    /* 31 : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),
+  },
+}