text
stringlengths 1
2.05k
|
|---|
fn rundot(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_dot");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let b = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = rundot
}
criterion_main!(benches |
); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Einsum {
equation: "ab,bc->ac".to_string(),
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_einsum_matmul");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 32].iter() {
unsafe {
LEN = len;
};
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
a.reshape(&[len, len]).unwrap();
let mut b = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
b.reshape(&[len, len]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_grou |
p! {
name = benches;
config = Criterion::default().with_plots();
targets = runmatmul
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::table::Range;
use ezkl::circuit::*;
use ezkl::circuit::lookup::LookupOp;
use ezkl::circuit::poly::PolyOp;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
const BITS: Range = (-32768, 32768);
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
} |
struct MyConfig {
base_config: BaseConfig<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = MyConfig;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
let mut base_config =
BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::UNSAFE);
base_config
.configure_lookup(cs, &b, &output, &a, BITS, K, &LookupOp::ReLU)
.unwrap();
MyConfig { base_config }
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
config.base_config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let op = PolyOp::Einsum {
equation: "ij,jk->ik".to_string(),
};
let mut region = region::RegionCtx::new(region, 0, 1);
let output = config
.base_config
.layout(&mut region, &self.inputs, Box::new(op))
.unwrap();
let _output = config
.base_config
.layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_matmul");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 32].iter() {
unsafe {
LEN = len;
};
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::from(1))));
a.reshape(&[len, len]).unwrap();
let mut b = Tensor::from((0..len).map(|_| Value::known(Fr::from(1))));
b.reshape(&[len, 1]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
co |
nfig = Criterion::default().with_plots();
targets = runmatmul
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::*;
use ezkl::circuit::lookup::LookupOp;
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::table::Range;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
const BITS: Range = (-8180, 8180);
static mut LEN: usize = 4;
static mut K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
} |
struct MyConfig {
base_config: BaseConfig<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = MyConfig;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let k = unsafe { K };
let a = VarTensor::new_advice(cs, k, 1, len);
let b = VarTensor::new_advice(cs, k, 1, len);
let output = VarTensor::new_advice(cs, k, 1, len);
let mut base_config =
BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::UNSAFE);
base_config
.configure_lookup(cs, &b, &output, &a, BITS, k, &LookupOp::ReLU)
.unwrap();
MyConfig { base_config }
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
config.base_config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let op = PolyOp::Einsum {
equation: "ij,jk->ik".to_string(),
};
let mut region = region::RegionCtx::new(region, 0, 1);
let output = config
.base_config
.layout(&mut region, &self.inputs, Box::new(op))
.unwrap();
let _output = config
.base_config
.layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runmatmul(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_matmul");
for &k in [8, 10, 11, 12, 13, 14].iter() {
let len = unsafe { LEN };
unsafe {
K = k;
};
let params = gen_srs::<KZGCommitmentScheme<_>>(k as u32);
let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::from(1))));
a.reshape(&[len, len]).unwrap();
let mut b = Tensor::from((0..len).map(|_| Value::known(Fr::from(1))));
b.reshape(&[len, 1]).unwrap();
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(k as u64));
group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
} |
criterion_group! {
name = benches;
config = Criterion::default().with_plots().sample_size(10);
targets = runmatmul
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 1],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&self.inputs,
Box::new(PolyOp::Sum { axes: vec![0] }),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runsum(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_sum");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runsum
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::hybrid::HybridOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
static mut IMAGE_HEIGHT: usize = 2;
static mut IMAGE_WIDTH: usize = 2;
static mut IN_CHANNELS: usize = 3;
const K: usize = 17; |
struct MyCircuit {
image: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = 10;
let a = VarTensor::new_advice(cs, K, 1, len * len);
let b = VarTensor::new_advice(cs, K, 1, len * len);
let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(
&mut region,
&[self.image.clone()],
Box::new(HybridOp::SumPool {
padding: vec![(0, 0); 2],
stride: vec![1, 1],
kernel_shape: vec![2, 2],
normalized: false,
}),
)
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runsumpool(c: &mut Criterion) {
let mut group = c.benchmark_group("accum_sumpool");
let params = gen_srs::<KZGCommitmentScheme<_>>(K as u32);
for size in [1, 2].iter() {
unsafe {
IMAGE_HEIGHT = size * 4;
IMAGE_WIDTH = size * 4;
let mut image = Tensor::from(
(0..IN_CHANNELS * IMAGE_HEIGHT * IMAGE_WIDTH)
.map(|_| Value::known(Fr::random(OsRng))),
);
image
.reshape(&[1, IN_CHANNELS, IMAGE_HEIGHT, IMAGE_WIDTH])
.unwrap();
let circuit = MyCircuit {
image: ValTensor::from(image),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
No |
ne,
None,
);
prover.unwrap();
});
});
}
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runsumpool
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 2],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = region::RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runadd(c: &mut Criterion) {
let mut group = c.benchmark_group("pairwise_add");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let b = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a), ValTensor::from(b)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runadd
}
criterion_main!(benc |
hes); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::poly::PolyOp;
use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::*;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
use std::marker::PhantomData;
static mut LEN: usize = 4;
const K: usize = 16; |
struct MyCircuit {
inputs: [ValTensor<Fr>; 1],
_marker: PhantomData<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = BaseConfig<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
let len = unsafe { LEN };
let a = VarTensor::new_advice(cs, K, 1, len);
let b = VarTensor::new_advice(cs, K, 1, len);
let output = VarTensor::new_advice(cs, K, 1, len);
Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE)
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
layouter.assign_region(
|| "",
|region| {
let mut region = RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runpow(c: &mut Criterion) {
let mut group = c.benchmark_group("pairwise_pow");
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [16, 512].iter() {
unsafe {
LEN = len;
};
let a = Tensor::from((0..len).map(|_| Value::known(Fr::random(OsRng))));
let circuit = MyCircuit {
inputs: [ValTensor::from(a)],
_marker: PhantomData,
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runpow
}
criterion_main!(benches); |
use std::collections::HashMap;
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
use ezkl::circuit::modules::poseidon::{PoseidonChip, PoseidonConfig};
use ezkl::circuit::modules::Module;
use ezkl::circuit::*;
use ezkl::pfsys::create_keys;
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::srs::gen_srs;
use ezkl::pfsys::TranscriptType;
use ezkl::tensor::*;
use halo2_proofs::circuit::Value;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
arithmetic::Field,
circuit::{Layouter, SimpleFloorPlanner},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::rngs::OsRng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
const L: usize = 10; |
struct MyCircuit {
image: ValTensor<Fr>,
}
impl Circuit<Fr> for MyCircuit {
type Config = PoseidonConfig<POSEIDON_WIDTH, POSEIDON_RATE>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, 10>::configure(cs, ())
}
fn synthesize(
&self,
config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
let chip: PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L> =
PoseidonChip::new(config);
chip.layout(&mut layouter, &[self.image.clone()], 0, &mut HashMap::new())?;
Ok(())
}
} |
fn runposeidon(c: &mut Criterion) {
let mut group = c.benchmark_group("poseidon");
for size in [64, 784, 2352, 12288].iter() {
let k = (PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::num_rows(*size)
as f32)
.log2()
.ceil() as u32;
let params = gen_srs::<KZGCommitmentScheme<_>>(k);
let message = (0..*size).map(|_| Fr::random(OsRng)).collect::<Vec<_>>();
let _output =
PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::run(message.to_vec())
.unwrap();
let mut image = Tensor::from(message.into_iter().map(Value::known));
image.reshape(&[1, *size]).unwrap();
let circuit = MyCircuit {
image: ValTensor::from(image),
};
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(*size as u64));
group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
MyCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM, |
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots().sample_size(10);
targets = runposeidon
}
criterion_main!(benches); |
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::table::Range;
use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
use ezkl::pfsys::create_proof_circuit;
use ezkl::pfsys::TranscriptType;
use ezkl::pfsys::{create_keys, srs::gen_srs};
use ezkl::tensor::*;
use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::poly::kzg::strategy::SingleStrategy;
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{Circuit, ConstraintSystem, Error},
};
use halo2curves::bn256::{Bn256, Fr};
use rand::Rng;
use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
const BITS: Range = (-32768, 32768);
static mut LEN: usize = 4;
const K: usize = 16; |
struct NLCircuit {
pub input: ValTensor<Fr>,
}
impl Circuit<Fr> for NLCircuit {
type Config = Config<Fr>;
type FloorPlanner = SimpleFloorPlanner;
type Params = ();
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
unsafe {
let advices = (0..3)
.map(|_| VarTensor::new_advice(cs, K, 1, LEN))
.collect::<Vec<_>>();
let nl = LookupOp::ReLU;
let mut config = Config::default();
config
.configure_lookup(cs, &advices[0], &advices[1], &advices[2], BITS, K, &nl)
.unwrap();
config
}
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<Fr>,
) -> Result<(), Error> {
config.layout_tables(&mut layouter).unwrap();
layouter.assign_region(
|| "",
|region| {
let mut region = RegionCtx::new(region, 0, 1);
config
.layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
.unwrap();
Ok(())
},
)?;
Ok(())
}
} |
fn runrelu(c: &mut Criterion) {
let mut group = c.benchmark_group("relu");
let mut rng = rand::thread_rng();
let params = gen_srs::<KZGCommitmentScheme<_>>(17);
for &len in [4, 8].iter() {
unsafe {
LEN = len;
};
let input: Tensor<Value<Fr>> =
Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();
let circuit = NLCircuit {
input: ValTensor::from(input.clone()),
};
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
b.iter(|| {
create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, ¶ms, true)
.unwrap();
});
});
let pk =
create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, ¶ms, true).unwrap();
group.throughput(Throughput::Elements(len as u64));
group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
b.iter(|| {
let prover = create_proof_circuit::<
KZGCommitmentScheme<_>,
NLCircuit,
ProverSHPLONK<_>,
VerifierSHPLONK<_>,
SingleStrategy<_>,
_,
EvmTranscript<_, _, _, _>,
EvmTranscript<_, _, _, _>,
>(
circuit.clone(),
vec![],
¶ms,
&pk,
CheckMode::UNSAFE,
ezkl::Commitments::KZG,
TranscriptType::EVM,
None,
None,
);
prover.unwrap();
});
});
}
group.finish();
}
criterion_group! {
name = benches;
config = Criterion::default().with_plots();
targets = runrelu
}
criterion_main!(benches); |
pragma solidity ^0.8.20; |
import './LoadInstances.sol';
contract DataAttestation is LoadInstances {
/**
* @notice Struct used to make view only calls to accounts to fetch the data that EZKL reads from.
* @param the address of the account to make calls to
* @param the abi encoded function calls to make to the `contractAddress`
*/ |
struct AccountCall {
address contractAddress;
mapping(uint256 => bytes) callData;
mapping(uint256 => uint256) decimals;
uint callCount;
}
AccountCall[] public accountCalls;
uint[] public scales;
address public admin;
/**
* @notice EZKL P value
* @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P), where n + P <= 2^256, we |
require that all instances are stricly less than P. a
* @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
*/
uint256 constant ORDER = uint256(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001);
uint256 constant INPUT_CALLS = 0;
uint256 constant OUTPUT_CALLS = 0;
uint8 public instanceOffset;
/**
* @dev Initialize the contract with account calls the EZKL model will read from.
* @param _contractAddresses - The calls to all the contracts EZKL reads storage from.
* @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
*/
constructor(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals,
uint[] memory _scales,
uint8 _instanceOffset,
address _admin
) {
admin = _admin;
for (uint i; i < _scales.length; i++) {
scales.push(1 << _scales[i]);
}
populateAccountCalls(_contractAddresses, _callData, _decimals);
instanceOffset = _instanceOffset;
}
function updateAdmin(address _admin) external {
require(msg.sender == admin, "Only admin can update admin");
if(_admin == address(0)) {
revert();
}
admin = _admin;
}
function updateAccountCalls(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals
) external {
require(msg.sender == admin, "Only admin can update instanceOffset");
populateAccountCalls(_contractAddresses, _callData, _decimals);
}
function populateAccountCalls(
address[] memory _contractAddresses,
bytes[][] memory _callData,
uint256[][] memory _decimals
) internal {
require(
_contractAddresses.length == _callData.length && |
accountCalls.length == _contractAddresses.length,
"Invalid input length"
);
require(
_decimals.length == _contractAddresses.length,
"Invalid number of decimals"
);
uint counter = 0;
for (uint256 i = 0; i < _contractAddresses.length; i++) {
AccountCall storage accountCall = accountCalls[i];
accountCall.contractAddress = _contractAddresses[i];
accountCall.callCount = _callData[i].length;
for (uint256 j = 0; j < _callData[i].length; j++) {
accountCall.callData[j] = _callData[i][j];
accountCall.decimals[j] = 10 ** _decimals[i][j];
}
counter += _callData[i].length;
}
require(counter == INPUT_CALLS + OUTPUT_CALLS, "Invalid number of calls");
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse; |
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
/**
* @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
* @param data - The data returned from the account calls.
* @param decimals - The number of decimals the data returned from the account calls has (for floating point representation).
* @param scale - The scale used to convert the floating point value into a fixed point value.
*/
function quantizeData(
bytes memory data,
uint256 decimals,
uint256 scale
) internal pure returns (int256 quantized_data) {
int x = abi.decode(data, (int256));
bool neg = x < 0;
if (neg) x = -x;
uint output = mulDiv(uint256(x), scale, decimals);
if (mulmod(uint256(x), scale, decimals) * 2 >= decimals) {
output += 1;
}
quantized_data = neg ? -int256(output): int256(output);
}
/**
* @dev Make a static call to the account to fetch the data that EZKL reads from.
* @param target - The address of the account to make calls to.
* @param data - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
* @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise)
*/
function staticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
if (success) {
if (returndata.length == 0) {
require(
target.code.length > 0,
"Address: call to non-contract"
); |
}
return returndata;
} else {
revert("Address: low-level call failed");
}
}
/**
* @dev Convert the fixed point quantized data into a field element.
* @param x - The quantized data.
* @return field_element - The field element.
*/
function toFieldElement(int256 x) internal pure returns (uint256 field_element) {
return uint256(x + int(ORDER)) % ORDER;
}
/**
* @dev Make the account calls to fetch the data that EZKL reads from and attest to the data.
* @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier).
*/
function attestData(uint256[] memory instances) internal view {
require(
instances.length >= INPUT_CALLS + OUTPUT_CALLS,
"Invalid public inputs length"
);
uint256 _accountCount = accountCalls.length;
uint counter = 0;
for (uint8 i = 0; i < _accountCount; ++i) {
address account = accountCalls[i].contractAddress;
for (uint8 j = 0; j < accountCalls[i].callCount; j++) {
bytes memory returnData = staticCall(
account,
accountCalls[i].callData[j]
);
uint256 scale = scales[counter];
int256 quantized_data = quantizeData(
returnData,
accountCalls[i].decimals[j],
scale
);
uint256 field_element = toFieldElement(quantized_data);
require(
field_element == instances[counter + instanceOffset],
"Public input does not match"
);
counter++;
}
}
}
function verifyWithDataAttestation(
address verifier,
bytes calldata encoded
) public view returns (bool) {
require(verifier.code.length > 0,"Address: call to non-contract"); |
attestData(getInstancesCalldata(encoded));
(bool success, bytes memory returndata) = verifier.staticcall(encoded);
if (success) {
return abi.decode(returndata, (bool));
} else {
revert("low-level call to verifier failed");
}
}
} |
pragma solidity ^0.8.20;
contract LoadInstances {
/**
* @dev Parse the instances array from the Halo2Verifier encoded calldata.
* @notice must pass encoded bytes from memory
* @param encoded - verifier calldata
*/
function getInstancesMemory(
bytes memory encoded
) internal pure returns (uint256[] memory instances) {
bytes4 funcSig;
uint256 instances_offset;
uint256 instances_length;
assembly {
funcSig := mload(add(encoded, 0x20))
instances_offset := mload(
add(encoded, add(0x44, mul(0x20, eq(funcSig, 0xaf83a18d))))
)
instances_length := mload(add(add(encoded, 0x24), instances_offset))
}
instances = new uint256[](instances_length);
assembly {
for {
let i := 0x20
} lt(i, add(mul(instances_length, 0x20), 0x20)) {
i := add(i, 0x20)
} {
mstore(
add(instances, i),
mload(add(add(encoded, add(i, 0x24)), instances_offset))
)
}
}
}
/**
* @dev Parse the instances array from the Halo2Verifier encoded calldata.
* @notice must pass encoded bytes from calldata
* @param encoded - verifier calldata
*/
function getInstancesCalldata(
bytes calldata encoded
) internal pure returns (uint256[] memory instances) {
bytes4 funcSig;
uint256 instances_offset;
uint256 instances_length;
assembly {
funcSig := calldataload(encoded.offset)
instances_offset := calldataload(
add(
encoded.offset,
add(0x24, mul(0x20, eq(funcSig, 0xaf83a18d)))
)
)
instances_length := calldataload(add(add(encoded.offset, 0x |
04), instances_offset))
}
instances = new uint256[](instances_length);
assembly{
for {
let i := 0x20
} lt(i, add(mul(instances_length, 0x20), 0x20)) {
i := add(i, 0x20)
} {
mstore(
add(instances, i),
calldataload(
add(add(encoded.offset, add(i, 0x04)), instances_offset)
)
)
}
}
}
} |
pragma solidity ^0.8.17;
contract QuantizeData {
/**
* @notice EZKL P value
* @dev In order to prevent the verifier from accepting two version of the same instance, n and the quantity (n + P), where n + P <= 2^256, we |
require that all instances are stricly less than P. a
* @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
*/
uint256 constant ORDER =
uint256(
0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
);
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https:
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos; |
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function quantize_data(
bytes[] memory data,
uint256[] memory decimals,
uint256[] memory scales
) external pure returns (int256[] memory quantized_data) {
quantized_data = new int256[](data.length);
for (uint i; i < data.length; i++) {
int x = abi.decode(data[i], (int256));
bool neg = x < 0;
if (neg) x = -x;
uint denom = 10 ** decimals[i];
uint scale = 1 << scales[i];
uint output = mulDiv(uint256(x), scale, denom);
if (mulmod(uint256(x), scale, denom) * 2 >= denom) {
output += 1;
}
quantized_data[i] = neg ? -int256(output) : int256(output);
}
}
function to_field_element(
int128[] memory quantized_data
) public pure returns (uint256[] memory output) {
output = new uint256[](quantized_data.length);
for (uint i; i < quantized_data.length; i++) {
output[i] = uint256(quantized_data[i] + int(ORDER)) % ORDER;
}
}
} |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
contract TestReads {
int[] public arr;
constructor(int256[] memory _numbers) {
for (uint256 i = 0; i < _numbers.length; i++) {
arr.push(_numbers[i]);
}
}
}
|
import ezkl
project = 'ezkl'
release = '0.0.0'
version = release
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.inheritance_diagram',
'sphinx.ext.autosectionlabel',
'sphinx.ext.napoleon',
'sphinx_rtd_theme',
]
autosummary_generate = True
autosummary_imported_members = True
templates_path = ['_templates']
exclude_patterns = []
# -- Options for HTML output -------------------------------------------------
# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
html_theme = 'sphinx_rtd_theme'
html_static_path = ['_static'] |
use ezkl::circuit::region::RegionCtx;
use ezkl::circuit::{
ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
};
use ezkl::fieldutils;
use ezkl::fieldutils::i32_to_felt;
use ezkl::tensor::*;
use halo2_proofs::dev::MockProver;
use halo2_proofs::poly::commitment::Params;
use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
use halo2_proofs::{
circuit::{Layouter, SimpleFloorPlanner, Value},
plonk::{
create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, Column, ConstraintSystem, Error,
Instance,
},
poly::{
commitment::ParamsProver,
kzg::{
commitment::{KZGCommitmentScheme, ParamsKZG},
strategy::SingleStrategy,
},
},
transcript::{
Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer,
},
};
use halo2curves::bn256::Bn256;
use halo2curves::bn256::Fr as F;
use instant::Instant;
use mnist::*;
use rand::rngs::OsRng;
use std::marker::PhantomData;
mod params;
const K: usize = 20;
const NUM_INNER_COLS: usize = 1;
struct Config<
const LEN: usize,
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> where
Value<F>: TensorType,
{
layer_config: PolyConfig<F>,
public_output: Column<Instance>,
}
struct MyCircuit<
const LEN: usize,
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> where
Value<F>: TensorType,
{
input: ValTensor<F>,
l0_params: [ValTenso |
r<F>; 2],
l2_params: [ValTensor<F>; 2],
}
impl<
const LEN: usize,
const CLASSES: usize,
const LOOKUP_MIN: i128,
const LOOKUP_MAX: i128,
const KERNEL_HEIGHT: usize,
const KERNEL_WIDTH: usize,
const OUT_CHANNELS: usize,
const STRIDE: usize,
const IMAGE_HEIGHT: usize,
const IMAGE_WIDTH: usize,
const IN_CHANNELS: usize,
const PADDING: usize,
> Circuit<F>
for MyCircuit<
LEN,
CLASSES,
LOOKUP_MIN,
LOOKUP_MAX,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
>
where
Value<F>: TensorType,
{
type Config = Config<
LEN,
CLASSES,
LOOKUP_MIN,
LOOKUP_MAX,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
>;
type FloorPlanner = SimpleFloorPlanner;
type Params = PhantomData<F>;
fn without_witnesses(&self) -> Self {
self.clone()
}
fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
let input = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
let params = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
let output = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
println!("INPUT COL {:
let mut layer_config = PolyConfig::configure(
cs,
&[input.clone(), params.clone()],
&output,
CheckMode::SAFE,
);
layer_config
.configure_lookup(
cs,
&input,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::ReLU,
)
.unwrap();
layer_config
.configure_lookup(
cs,
&inpu |
t,
&output,
¶ms,
(LOOKUP_MIN, LOOKUP_MAX),
K,
&LookupOp::Div { denom: 32.0.into() },
)
.unwrap();
let public_output: Column<Instance> = cs.instance_column();
cs.enable_equality(public_output);
Config {
layer_config,
public_output,
}
}
fn synthesize(
&self,
mut config: Self::Config,
mut layouter: impl Layouter<F>,
) -> Result<(), Error> {
config.layer_config.layout_tables(&mut layouter).unwrap();
let x = layouter
.assign_region(
|| "mlp_4d",
|region| {
let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
let op = PolyOp::Conv {
padding: vec![(PADDING, PADDING); 2],
stride: vec![STRIDE; 2],
};
let x = config
.layer_config
.layout(
&mut region,
&[
self.input.clone(),
self.l0_params[0].clone(),
self.l0_params[1].clone(),
],
Box::new(op),
)
.unwrap();
let x = config
.layer_config
.layout(&mut region, &[x.unwrap()], Box::new(LookupOp::ReLU))
.unwrap();
let mut x = config
.layer_config
.layout(
&mut region,
&[x.unwrap()],
Box::new(LookupOp::Div { denom: 32.0.into() }),
)
.unwrap()
.unwrap();
x.fla |
tten();
let x = config
.layer_config
.layout(
&mut region,
&[self.l2_params[0].clone(), x],
Box::new(PolyOp::Einsum {
equation: "ij,j->ik".to_string(),
}),
)
.unwrap()
.unwrap();
let x: ValTensor<F> = config
.layer_config
.layout(
&mut region,
&[x, self.l2_params[1].clone()],
Box::new(PolyOp::Add),
)
.unwrap()
.unwrap();
Ok(x)
},
)
.unwrap();
match x {
ValTensor::Value {
inner: v, dims: _, ..
} => v
.enum_map(|i, x| match x {
ValType::PrevAssigned(v) => {
layouter.constrain_instance(v.cell(), config.public_output, i)
}
_ => panic!(),
})
.unwrap(),
_ => panic!("Should be assigned"),
};
Ok(())
}
}
pub |
fn runconv() {
env_logger::init();
const KERNEL_HEIGHT: usize = 5;
const KERNEL_WIDTH: usize = 5;
const OUT_CHANNELS: usize = 4;
const STRIDE: usize = 2;
const IMAGE_HEIGHT: usize = 28;
const IMAGE_WIDTH: usize = 28;
const IN_CHANNELS: usize = 1;
const PADDING: usize = 0;
const CLASSES: usize = 10;
const LEN: usize = {
OUT_CHANNELS
* ((IMAGE_HEIGHT + 2 * PADDING - KERNEL_HEIGHT) / STRIDE + 1)
* ((IMAGE_WIDTH + 2 * PADDING - KERNEL_WIDTH) / STRIDE + 1)
};
let Mnist {
trn_img,
trn_lbl,
tst_img: _,
tst_lbl: _,
..
} = MnistBuilder::new()
.base_path("examples/data")
.label_format_digit()
.training_set_length(50_000)
.validation_set_length(10_000)
.test_set_length(10_000)
.finalize();
let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
train_data.reshape(&[50_000, 28, 28]).unwrap();
let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
train_labels.reshape(&[50_000, 1]).unwrap();
println!("The first digit is a {:?}", train_labels[0]);
let mut input: ValTensor<F> = train_data
.get_slice(&[0..1, 0..28, 0..28])
.unwrap()
.map(Value::known)
.into();
input.reshape(&[1, 1, 28, 28]).unwrap();
let myparams = params::Params::new();
let mut l0_kernels = Tensor::<F>::from(
myparams
.kernels
.clone()
.into_iter()
.flatten()
.flatten()
.flatten()
.map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}),
);
l0_kernels
.reshape(&[OUT_CHANNELS, IN_CHANNELS, KERNEL_HEIGHT, KERNEL_WIDTH])
.unwrap();
l0_kernels.set_visibility(&ezkl |
::graph::Visibility::Private);
let l0_kernels = l0_kernels.try_into().unwrap();
let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
let l0_bias = l0_bias.try_into().unwrap();
let mut l2_biases = Tensor::<F>::from(myparams.biases.into_iter().map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}));
l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
let l2_biases = l2_biases.try_into().unwrap();
let mut l2_weights = Tensor::<F>::from(myparams.weights.into_iter().flatten().map(|fl| {
let dx = fl * 32_f32;
let rounded = dx.round();
let integral: i32 = unsafe { rounded.to_int_unchecked() };
fieldutils::i32_to_felt(integral)
}));
l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
l2_weights.reshape(&[CLASSES, LEN]).unwrap();
let l2_weights = l2_weights.try_into().unwrap();
let circuit = MyCircuit::<
LEN,
10,
-32768,
32768,
KERNEL_HEIGHT,
KERNEL_WIDTH,
OUT_CHANNELS,
STRIDE,
IMAGE_HEIGHT,
IMAGE_WIDTH,
IN_CHANNELS,
PADDING,
> {
input,
l0_params: [l0_kernels, l0_bias],
l2_params: [l2_weights, l2_biases],
};
let public_input: Tensor<i32> = vec![
-25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
]
.into_iter()
.into();
let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);
println!("MOCK PROVING");
let now = Instant::now();
let prover = MockProver::run(
K as u32,
&circuit,
vec![pi_inner.clone().into_iter().collect()],
)
.unwrap();
prover.assert_satisfied();
let elapsed = now.elapsed(); |
println!(
"MOCK PROVING took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let pi_for_real_prover: &[&[&[F]]] = &[&[&pi_inner]];
println!("SRS GENERATION");
let now = Instant::now();
let params: ParamsKZG<Bn256> = ParamsKZG::new(K as u32);
let elapsed = now.elapsed();
println!(
"SRS GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let empty_circuit = circuit.without_witnesses();
println!("VK GENERATION");
let now = Instant::now();
let vk = keygen_vk(¶ms, &empty_circuit).expect("keygen_vk should not fail");
let elapsed = now.elapsed();
println!(
"VK GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
println!("PK GENERATION");
let now = Instant::now();
let pk = keygen_pk(¶ms, vk, &empty_circuit).expect("keygen_pk should not fail");
let elapsed = now.elapsed();
println!(
"PK GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
println!("PROOF GENERATION");
let now = Instant::now();
let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
let mut rng = OsRng;
create_proof::<KZGCommitmentScheme<_>, ProverSHPLONK<_>, _, _, _, _>(
¶ms,
&pk,
&[circuit],
pi_for_real_prover,
&mut rng,
&mut transcript,
)
.expect("proof generation should not fail");
let proof = transcript.finalize();
let elapsed = now.elapsed();
println!(
"PROOF GENERATION took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
let now = Instant::now();
let strategy = SingleStrategy::new(¶ms);
let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
let verify = verify_proof::<_, VerifierSHPLONK<_>, _, _, _>(
¶ms,
pk.get_vk(),
strategy,
pi_for_real_prover,
&mut transcript, |
params.n(),
);
assert!(verify.is_ok());
let elapsed = now.elapsed();
println!(
"Verify took {}.{}",
elapsed.as_secs(),
elapsed.subsec_millis()
);
} |
fn main() {
runconv()
} |
pub |
struct Params {
pub kernels: Vec<Vec<Vec<Vec<f32>>>>,
pub weights: Vec<Vec<f32>>,
pub biases: Vec<f32>,
}
impl Params {
pub fn new() -> Params {
let kernels: Vec<Vec<Vec<Vec<f32>>>> = vec![
vec![
vec![vec![
-0.109_487_005,
0.909_935_65,
0.328_405_1,
0.155_579_06,
]],
vec![vec![
-0.471_988_14,
0.322_556_82,
0.157_859_01,
-0.081_366_19,
]],
vec![vec![
-0.321_307_9,
-0.709_357_5,
-0.236_524_24,
0.018_392_317,
]],
vec![vec![
-0.960_573_43,
-0.846_240_9,
-0.198_723_21,
0.338_416_52,
]],
vec![vec![
0.166_024_16,
0.430_398_14,
0.047_989_722,
0.390_401_57,
]],
],
vec![
vec![vec![0.179_814_12, 0.948_680_9, 0.071_443_19, 0.617_541_6]],
vec![vec![-0.697_547_9, -0.965_234_34, 0.536_243_9, 0.735_313_3]],
vec![vec![-0.856_151_64, -1.370_123, 0.471_787_6, 0.621_356_9]],
vec![vec![
-1.038_033_6,
-0.314_346_02,
0.054_190_256,
0.157_560_56,
]],
vec![vec![
-1.257_821_7,
0.592_307_27,
-0.602_756_1,
-0.045_588_925,
]],
],
vec![
vec![vec![
0.768_956_36,
-0.270_884_07,
0.018_818_572,
0.856_514_2,
]],
vec![vec![0 |
.106_152_184, -1.894_055_7, 0.410_578_52, 1.128_321_6]],
vec![vec![0.258_462_85, -0.788_394_3, 0.439_590_57, 0.347_620_25]],
vec![vec![
-0.285_630_46,
0.344_891_73,
-0.158_083_84,
0.046_936_575,
]],
vec![vec![-1.207_216_4, 0.972_309_4, -1.463_360_5, 0.158_549_34]],
],
vec![
vec![vec![
0.481_335_2,
-0.999_390_1,
-0.342_961_97,
-0.462_902_43,
]],
vec![vec![0.770_321_5, -0.693_961_4, 0.349_121_36, -0.411_381_07]],
vec![vec![0.576_287_75, 0.283_153_83, 1.110_488_4, 0.188_614_32]],
vec![vec![0.697_886_77, 0.836_453_6, -0.077_697_74, 0.236_429_83]],
vec![vec![0.525_762_26, 0.838_75, -1.107_396_1, 0.395_158_26]],
],
vec![
vec![vec![0.165_011_53, -0.900_041_6, 0.047_026_41, -1.977_776]],
vec![vec![
0.307_094_28,
-0.446_277_47,
0.300_544_77,
-1.988_659_1,
]],
vec![vec![0.406_012_42, 0.884_344_8, 0.952_605_9, -0.506_538]],
vec![vec![0.980_571_8, 0.721_017_2, 0.290_006_73, -0.175_620_02]],
vec![vec![0.928_422_87, 0.359_928_97, -0.923_574_2, 0.063_738_97]],
],
];
let w: Vec<Vec<f32>> = vec![
vec![
0.205_270_19,
-0.103_883_29,
-0.899_116_8,
0.729_005_6,
-0.240_855_54,
0.212_849_54,
-0.417_299_66,
-1.158_180_5,
-1.631_655_5,
-0.357_596_07,
],
vec![
0.554_331_5,
-0.113_753_23,
-0.998_434_54,
0.527_284_1, |
-0.702_836_16,
0.852_934_1,
-0.762_695,
-1.032_534_8,
-1.304_348_8,
-0.461_081_1,
],
vec![
0.235_476_17,
0.933_593,
-0.580_496_9,
0.104_375_89,
-0.041_980_47,
-0.653_047_9,
-0.642_941_1,
-0.055_830_125,
-0.506_560_2,
-0.054_289_315,
],
vec![
0.531_130_25,
-0.422_383_3,
-0.913_531_6,
0.379_514_9,
-0.694_251_5,
0.636_398_9,
-0.583_917_3,
-1.094_018_2,
-0.767_574_3,
-0.250_628_44,
],
vec![
0.210_465_77,
-0.651_549_34,
0.430_768_22,
0.073_381_59,
-0.726_815_46,
-0.955_648_3,
0.060_921_72,
-1.645_878_4,
-0.245_945_47,
-1.102_198_2,
],
vec![
-0.720_487_3,
-0.537_216_1,
0.213_335_25,
0.261_519,
-0.752_857_7,
-0.974_760_83,
0.801_267_15,
-1.639_844_2,
-0.296_582_34,
-0.877_851_4,
],
vec![
0.286_137_55,
-0.717_753_95,
0.174_010_41,
-0.781_800_03,
-0.391_660_15,
0.916_126_9,
-0.611_720_1,
-0.838_970_3,
-1.248_522_9,
-0.266_078_17,
],
vec![
0.786_667_5,
-1.937_995_7,
1.488_519_2,
-1.075_065,
-0.816_913_96,
-0.082_72 |
6_15,
0.544_172_8,
-0.647_251_5,
0.042_277_988,
-0.101_091_36,
],
vec![
-0.081_334_39,
-0.410_865_6,
4.723_240_3e-5,
0.167_322_04,
-0.229_562_98,
-0.362_416_1,
0.258_705_38,
-1.749_157_9,
0.071_778_66,
-2.777_862_5,
],
vec![
-0.085_456_52,
-1.244_134_9,
0.120_452_59,
0.158_306_17,
-0.578_419_6,
-0.349_570_4,
0.537_034,
-1.344_408,
-0.028_031_735,
-2.276_252,
],
vec![
-1.502_647_6,
0.309_662_8,
0.248_574_35,
-0.207_915_56,
-1.259_506_8,
-1.270_181_1,
1.259_249_8,
-1.636_723,
0.053_503_122,
-0.590_245_2,
],
vec![
0.065_632_41,
-0.254_215_4,
-0.589_417_6,
1.104_314_7,
-1.895_038_4,
-0.648_805_4,
1.669_961_3,
-1.083_259_8,
-0.401_768_77,
-1.511_640_2,
],
vec![
0.249_498_64,
-0.175_782_26,
-0.258_627_98,
0.194_892_62,
-0.560_735_17,
-0.160_784_18,
0.161_112_1,
-3.568_600_4,
0.172_535_03,
-0.239_725_56,
],
vec![
0.248_165_12,
-0.169_096_62,
0.112_139_55,
-0.364_031_9,
-1.327_239_8,
-0.027_334_109,
0.536_611_86, |
-3.214_496_4,
0.130_880_97,
-0.526_202_7,
],
vec![
-0.799_813_03,
1.452_860_1,
-0.319_819_72,
-0.184_792_74,
0.140_319_36,
-0.867_999_26,
0.693_308_35,
-1.197_729_1,
-0.766_039_6,
-1.556_379_1,
],
vec![
-0.845_276_3,
0.304_203_3,
0.944_849_8,
0.124_821_134,
-0.922_336_76,
-0.491_067_53,
-0.184_880_93,
-2.557_060_7,
-1.775_722_1,
0.558_45,
],
vec![
0.143_072_8,
-0.264_300_5,
-0.081_971_504,
0.048_953_265,
-0.542_625,
0.011_722_911,
-0.333_903_73,
-0.390_692_65,
0.272_231_76,
0.156_067_22,
],
vec![
-0.387_689_44,
0.191_336_14,
-0.097_416_42,
0.035_105_634,
-0.395_439_33,
-0.242_016_94,
0.365_376_65,
-0.286_892_18,
-0.460_546_08,
0.274_879_22,
],
vec![
-0.286_709_82,
0.791_482_3,
0.646_904_4,
-0.833_426_06,
-0.655_702_65,
-0.107_309_21,
0.858_584_76,
-1.800_347_8,
-1.091_450_2,
-3.117_647,
],
vec![
-0.311_940_76,
0.585_462_15,
0.278_351_4,
-0.195_842_67,
-0.772_845_7,
0.177_592_13,
-0.098_054_45,
-1.845_965_5, |
-1.022_349_2,
-0.907_678_4,
],
vec![
0.272_821_28,
-0.067_864_05,
-0.138_505_9,
-0.081_492_29,
-0.387_334_82,
-0.016_360_57,
-0.215_009_03,
-0.167_551_83,
0.102_085_34,
0.173_719_73,
],
vec![
-0.090_551_52,
0.208_982_07,
-0.150_085_8,
-0.553_895_7,
-0.287_771_4,
-0.334_054_1,
0.267_900_44,
-0.272_997_17,
-0.337_444_4,
-0.042_845_86,
],
vec![
-0.356_198_94,
0.072_102_97,
0.102_510_154,
-0.196_657_39,
-0.191_161_19,
-0.281_018_23,
0.778_014_7,
-1.820_609_9,
-0.116_903_074,
-1.093_936_6,
],
vec![
-1.026_930_8,
1.145_142_8,
-0.365_834_41,
0.112_254_17,
-0.342_273_4,
-1.065_313_3,
0.572_839_44,
-2.689_278_1,
-0.829_139_9,
-1.090_214_4,
],
vec![
0.049_006_45,
-0.238_958_63,
0.072_469_26,
0.021_633_074,
-0.253_975_12,
0.073_988_98,
-0.179_797_55,
-0.204_893_05,
0.084_148_675,
0.454_873_56,
],
vec![
-0.472_980_65,
0.094_130_29,
0.010_865_513,
-0.072_856_374,
-0.130_805_84,
0.288_349_66,
0.133_428_38,
-1.906_852,
-0.256_083_5, |
0.130_116_46,
],
vec![
0.310_519_2,
0.158_036_98,
-0.088_624_336,
-0.378_656_36,
-0.505_495_8,
-0.353_957_36,
0.128_528_24,
-0.121_506_3,
0.106_705_7,
0.053_275_537,
],
vec![
0.404_991_5,
-0.886_301_64,
1.029_255_2,
0.946_611_64,
-1.078_323_2,
-0.478_881_12,
0.080_937_55,
-0.968_548_6,
-0.184_279_47,
-3.533_551_5,
],
vec![
0.011_388_913,
-0.327_091_72,
0.107_985_206,
0.054_274_764,
-0.060_456_365,
-0.059_907_958,
-0.374_292_46,
-0.328_351_89,
0.065_400_75,
0.415_573_6,
],
vec![
0.106_242_32,
0.290_615_23,
-0.515_454_4,
-0.672_065,
-0.247_548_16,
0.608_504_4,
-0.016_324_794,
-4.148_192_4,
-0.212_008_9,
-0.432_835_8,
],
vec![
-0.526_448_97,
0.205_754_35,
0.076_098_82,
-0.069_695_31,
-0.191_621_91,
0.291_678_22,
-0.152_594_2,
0.101_625_93,
0.214_410_33,
-0.125_688_2,
],
vec![
-1.190_686_7,
-0.957_843_84,
0.998_908_6,
1.184_374_7,
-1.852_929_7,
0.349_038_24,
0.564_113_3,
-1.171_722_8,
-0.685_080_77,
-1.525_082_7,
], |
vec![
-0.121_344_47,
0.014_777_94,
0.092_460_57,
0.227_560_82,
-0.133_595_06,
-0.061_949_328,
-0.229_687_59,
-1.204_043_5,
-0.117_137_89,
0.066_422_805,
],
vec![
-0.713_826_5,
0.662_813_8,
-0.893_180_2,
-0.241_316_48,
-0.155_127_45,
0.235_396_18,
0.434_296,
-4.804_617,
-0.143_494_13,
-0.871_146_5,
],
vec![
-0.257_979_33,
0.148_611_19,
-0.216_227,
0.063_711_99,
-0.247_472_02,
0.096_262_21,
0.213_341_3,
-0.876_289_25,
0.040_421_054,
-0.139_267_49,
],
vec![
-0.095_453_01,
-1.067_049_1,
-0.109_649_43,
-0.193_885_3,
-1.734_969_9,
-0.106_661_83,
1.129_675_5,
-1.453_956_5,
0.904_227_4,
-1.171_946_4,
],
vec![
-0.039_940_894,
0.063_756_41,
-0.203_613_64,
0.329_066_4,
-0.183_243_96,
0.100_813_02,
-0.053_472_206,
0.535_816_67,
-0.316_393_52,
-0.144_898_12,
],
vec![
0.113_168_314,
-0.833_849_9,
-0.303_433_6,
-0.302_232_6,
0.228_052_87,
-0.354_127_2,
0.388_441_03,
0.625_805_4,
0.004_380_497_6,
-2.595_726,
],
vec![
0.1 |
43_565_1,
0.182_829_17,
-0.528_689_74,
-0.110_325_485,
-0.503_309_8,
0.299_748_33,
0.095_951_79,
-2.118_308_3,
-0.408_070_4,
0.146_073_6,
],
vec![
0.103_533_98,
0.597_761_1,
-1.624_569_9,
-1.605_465,
-1.133_732_3,
0.041_046_087,
0.620_659_6,
-1.410_499_7,
0.648_047_27,
-0.474_848_9,
],
vec![
0.221_853_54,
-0.451_183_77,
-0.257_857_44,
0.264_325_53,
-0.355_948_24,
0.014_300_789,
-0.059_305_04,
0.556_209,
-0.052_184_805,
-0.290_411_74,
],
vec![
0.123_746_41,
0.146_830_04,
0.365_464_8,
-2.524_588_8,
-0.209_791_47,
-0.002_517_690_6,
0.155_493_72,
-3.591_966_6,
-0.447_013_94,
-1.130_127,
],
vec![
0.217_829_11,
0.214_957_76,
0.282_495_92,
0.167_459_32,
-0.208_813_38,
-0.567_943_75,
0.198_498_55,
0.576_863_3,
-0.373_066_4,
-0.126_371_68,
],
vec![
-1.161_503_4,
-0.850_141_2,
0.323_090_46,
-1.075_380_4,
-0.876_660_05,
1.076_255_4,
-0.314_113_7,
-0.304_621_55,
-1.264_679_4,
-0.264_382_12,
],
vec![
0.149_401_25,
-0.976_069_4, |
0.511_743_55,
0.000_535_424_04,
-0.117_031_43,
-0.107_678_935,
-0.069_459_68,
0.306_292_47,
0.125_225_45,
-2.442_781,
],
vec![
-1.668_387_7,
-1.762_069_5,
-0.121_069_3,
-1.923_070_9,
0.618_881_46,
-0.254_279_52,
-0.053_265_8,
-1.291_394_6,
-0.296_294_72,
-0.343_077_6,
],
vec![
0.011_316_772,
-0.560_516_9,
0.481_444_72,
-0.479_095_2,
0.200_686_35,
-0.106_225_66,
-0.037_240_833,
0.214_261_46,
-0.261_465_5,
-1.978_262_7,
],
vec![
-0.720_068_8,
-0.210_179_06,
-0.971_435_2,
-0.758_882_5,
-0.857_823_85,
-0.485_705_32,
1.141_667_8,
-0.028_217_256,
-0.530_086_4,
-0.159_677_88,
],
vec![
0.177_069_29,
-0.121_254_206,
0.224_838_26,
0.371_999_23,
-0.589_339_85,
-0.052_119_676,
-0.246_520_33,
-0.337_158_02,
-0.360_983_88,
-1.255_084_3,
],
vec![
-0.642_535_27,
0.163_133,
0.069_549_456,
0.491_649_72,
-0.022_372_723,
0.203_867_21,
-0.479_860_75,
-0.587_429_9,
-0.627_623_2,
-1.301_936_3,
],
vec![
0.147_011_62,
0.614_845_7,
-0.894_ |
145_9,
-0.523_223_1,
-0.561_377_64,
0.613_864_54,
-0.745_141_27,
0.978_213_97,
-1.130_499_4,
-1.302_783_1,
],
vec![
0.695_418_36,
0.025_962_515,
-0.275_048_73,
0.853_301_6,
-0.425_614_98,
0.232_753_16,
-0.370_581_36,
-0.891_797_36,
-0.212_364_4,
-0.441_128_16,
],
vec![
0.467_095_23,
0.164_520_4,
-0.320_856_18,
-0.053_149_23,
0.166_585_9,
0.201_401_62,
-0.586_135_57,
-0.012_367_41,
-0.328_987_12,
-0.114_124_13,
],
vec![
0.236_447_05,
0.298_628_18,
-0.193_423_94,
0.009_453_123,
-0.490_039_44,
-0.417_519_3,
-0.036_829_55,
0.104_782_78,
-0.154_328_51,
-0.428_794_86,
],
vec![
0.521_462_1,
-1.067_498_9,
-0.352_910_64,
-0.706_459_64,
-0.156_912_03,
0.753_26,
-0.110_429_8,
0.179_951_94,
-1.210_509_1,
-0.272_030_9,
],
vec![
0.229_667_75,
0.585_958_8,
0.063_965_224,
-0.108_399_93,
-0.930_658_34,
-0.778_497_16,
-0.088_825_43,
0.233_678_62,
-0.337_286_65,
0.182_365_06,
],
vec![
0.048_408_65,
-0.036_042_29,
0.416_218_55,
-0.182 |
_036_67,
-0.523_173_2,
-0.128_682_4,
-0.118_689_634,
-0.138_312_35,
-0.105_193_26,
0.449_392_4,
],
vec![
-0.074_198_395,
-0.436_481_77,
0.101_361_58,
0.039_507_54,
-0.011_397_873,
-0.430_790_33,
0.255_392_58,
-0.574_166_9,
0.086_148_12,
0.122_888_364,
],
vec![
-0.855_785_55,
0.457_752_32,
-1.275_530_5,
0.259_120_94,
-0.464_194_15,
0.188_488_56,
1.413_801_8,
-0.357_694_63,
-1.278_620_5,
-1.631_098_6,
],
vec![
-0.805_655_2,
-0.265_815_73,
0.124_419_026,
-0.461_629_48,
-0.314_236_97,
0.268_423_3,
0.274_402_47,
0.998_315_93,
0.380_863_43,
-0.614_466_97,
],
vec![
-0.233_871_01,
-0.302_981_8,
0.258_206_84,
-0.005_351_850_8,
-0.144_955_49,
-0.253_221_06,
-0.228_432_7,
0.090_228_595,
0.008_581_011,
0.184_043_18,
],
vec![
-0.209_811_84,
0.012_808_64,
-0.203_015_6,
-0.114_540_905,
-0.157_946_11,
-0.070_131_48,
0.271_216_4,
-0.113_623_81,
0.058_057_647,
0.014_067_203,
],
vec![
-0.972_353_8,
1.463_821_9,
-0.622_333,
-0.397_985_52, |
1.035_312_5,
-0.610_709_37,
0.239_632_68,
-0.255_446_08,
0.016_936_108,
-1.764_247_2,
],
vec![
-0.260_985_3,
1.254_787_1,
0.186_725_72,
-0.455_625_27,
-0.066_667_27,
0.593_635_2,
0.162_254_18,
0.099_562_53,
-1.217_950_8,
-1.794_823_9,
],
vec![
0.041_862_838,
0.140_515_88,
0.050_972_044,
0.157_721_89,
-0.544_736_7,
-0.090_700_32,
-0.086_753_72,
0.072_839_975,
0.126_270_53,
-0.009_919_372,
],
vec![
-0.191_297_02,
0.391_595_66,
-0.347_080_17,
0.007_070_528,
0.079_755_33,
0.077_444_814,
0.275_881_83,
-0.337_502_7,
0.132_838_65,
-0.203_929_53,
],
vec![
0.353_786_1,
1.386_378_4,
-0.448_180_6,
-0.091_514_84,
0.470_257_67,
-0.466_944_75,
0.277_010_8,
-0.946_052_85,
-0.480_009_35,
-1.484_195_4,
],
vec![
-0.756_496_9,
-0.673_428_5,
0.142_579_26,
0.279_415_43,
1.044_289,
0.074_700_67,
-0.329_739_03,
1.033_776,
-0.044_540_51,
-1.185_075_5,
],
vec![
0.016_420_702,
-0.481_048_32,
0.133_203_77,
0.279_789_4,
-0.584_399,
0.082 |
_969_56,
-0.625_780_2,
0.033_153_057,
0.104_334_9,
0.392_508_8,
],
vec![
-0.214_637_23,
0.187_661_42,
-0.509_873_2,
-0.175_593_53,
0.585_934_34,
-0.163_800_21,
0.677_062_8,
-0.294_775_52,
0.273_286_88,
-0.762_537_36,
],
vec![
-0.274_889_4,
0.610_465_76,
0.456_998_2,
-0.148_116_63,
0.434_490_23,
-0.446_525_13,
0.168_362_99,
-0.592_147_05,
-0.428_666_38,
0.017_922_09,
],
vec![
-0.867_463_77,
0.263_241_74,
0.439_303_04,
0.250_574_17,
0.456_202_2,
-0.278_351_84,
-0.850_352_35,
-0.670_502_54,
0.253_216_77,
-3.358_240_8,
],
vec![
0.170_602_65,
-0.221_394_14,
-0.018_658_5,
0.224_552_65,
-0.444_447_9,
0.027_889_86,
-0.072_897_17,
0.025_849_128,
0.000_449_741_7,
0.120_267_78,
],
vec![
0.094_457_65,
0.749_140_1,
-0.441_342_3,
-0.247_712_64,
0.380_680_47,
-0.539_401_77,
0.374_145_78,
-0.637_63,
-0.102_575_146,
-0.444_776_6,
],
vec![
0.092_296_37,
0.324_160_07,
0.053_874_45,
-0.419_170_38,
0.080_262_61,
0.034_971_14,
0.339_625 |
_27,
-0.456_453_14,
0.155_008_8,
-0.545_077_7,
],
vec![
-0.144_919_11,
-0.484_287_77,
0.351_345_36,
1.020_092_8,
-0.322_258_44,
-0.290_137_68,
-0.837_886,
0.588_037_5,
-0.001_021_652_7,
-3.884_543_2,
],
vec![
0.115_526_795,
-0.034_962_557,
-0.139_396_6,
0.033_680_24,
-0.342_877_4,
0.083_684_86,
-0.122_894_36,
0.324_849_55,
-0.114_528_82,
0.123_401_18,
],
vec![
-0.137_530_28,
0.318_438_35,
-0.206_170_47,
-0.477_281_78,
0.460_907_3,
0.056_528_006,
0.050_785_955,
-0.574_258_3,
-0.024_915_818,
-0.404_091_6,
],
vec![
-0.202_853_07,
-0.103_542_28,
-0.116_601_42,
0.144_897_67,
-0.017_747_866,
0.235_582_32,
0.170_953_4,
-0.053_962_417,
-0.127_650_17,
-0.203_697_12,
],
vec![
0.152_913_54,
-0.516_011_83,
0.483_596_56,
0.244_190_16,
-0.029_850_394,
-0.097_673_82,
-0.312_583_42,
-1.341_605_7,
-0.423_485_9,
-0.279_781_43,
],
vec![
0.068_590_745,
-0.149_233_73,
-0.073_714_636,
0.042_948_257,
-0.197_927_46,
-0.022_572_309,
-0.224_327_13, |
0.327_125_85,
0.043_589_164,
-0.018_358_223,
],
vec![
-0.294_240_27,
0.677_863_1,
-0.482_854_16,
-0.791_775_4,
0.785_504_2,
-0.272_481_23,
0.286_275_3,
-1.218_818_8,
-0.021_499_386,
-0.722_086_67,
],
vec![
-0.177_391_37,
0.223_915_52,
-0.092_343_53,
-0.066_849_515,
0.131_875_72,
0.368_566_87,
-0.151_181_6,
-0.401_858_78,
-0.131_481_93,
-0.093_791_075,
],
vec![
0.508_870_1,
-0.971_894_44,
0.366_849_9,
0.131_068_99,
-0.605_050_1,
-0.326_536_66,
0.050_295_74,
-2.077_97,
0.215_176_37,
-1.826_045_4,
],
vec![
0.156_527_64,
-0.116_625_85,
0.154_377_33,
0.154_419_14,
-0.241_974_06,
-0.418_938_8,
-0.295_733_45,
0.149_280_2,
0.067_916_89,
0.028_793_553,
],
vec![
-0.158_543_56,
0.413_012_92,
-0.627_065_3,
-1.317_622,
0.208_255_17,
0.317_041_13,
-0.227_730_59,
0.398_595_12,
-0.352_214_3,
-0.824_505_45,
],
vec![
-0.161_441_8,
0.121_852_77,
-0.270_927_64,
-0.047_329_85,
-0.524_744_7,
0.105_052_55,
0.023_019_264,
0.050_272_036, |
0.119_445_64,
0.246_476_17,
],
vec![
-0.147_019_95,
-1.217_400_7,
0.256_482_8,
-0.399_383_75,
-1.991_811_2,
0.190_690_77,
-0.004_192_297,
0.097_936_116,
0.379_179_87,
-0.968_338_3,
],
vec![
0.106_748_596,
0.093_080_916,
0.073_558_204,
0.456_351_52,
-0.196_805_95,
-0.407_231_93,
-0.167_090_68,
-0.462_795_7,
-0.056_798_77,
0.363_880_04,
],
vec![
0.067_087_81,
0.700_592_1,
-2.085_968_3,
-1.309_445_1,
0.235_306_9,
0.437_614_35,
-0.111_600_46,
-0.668_872_65,
0.131_418_2,
-1.099_951,
],
vec![
0.120_559_655,
-0.173_647_66,
0.087_945_215,
0.011_596_556,
0.138_631_33,
-0.457_137_44,
-0.219_191_34,
0.418_845_4,
0.058_534_283,
-0.049_473_75,
],
vec![
-1.158_622_6,
-0.606_912_6,
-0.061_822_26,
-1.256_837_7,
-0.777_147_77,
0.427_778_1,
-0.644_817_6,
-2.014_167,
0.601_345_54,
-2.429_726,
],
vec![
0.324_109_85,
0.111_482_88,
0.177_295_82,
0.801_780_64,
-0.232_152_54,
0.068_763_666,
-0.246_951_58,
-1.317_435_4,
-0.205_863_16, |
-0.434_466_93,
],
vec![
-1.748_575_2,
-2.571_439,
0.583_557_6,
-2.421_854_5,
-0.827_151,
0.664_516,
0.625_516_6,
-2.512_756_6,
0.469_817_76,
-2.431_587_2,
],
vec![
-0.067_664_62,
-0.206_810_13,
-0.029_682_456,
0.605_365_75,
-0.336_148_23,
-0.151_250_17,
-0.282_517_22,
-0.148_410_19,
0.169_121_22,
-0.164_390_13,
],
vec![
-1.392_889,
-1.023_818_9,
-1.862_098_8,
-1.219_547_2,
-0.623_446_46,
0.318_364_47,
-0.479_301_15,
-2.804_167_7,
0.677_353_2,
-1.441_338_1,
],
vec![
-0.861_262_9,
0.004_425_101,
-0.071_183_55,
-0.184_647_08,
0.031_291_18,
-1.227_623_5,
-0.386_703_46,
0.281_736_55,
-0.005_909_541_6,
-0.399_945_47,
],
vec![
-0.701_130_03,
-0.117_758_64,
0.368_344_07,
0.331_284_97,
-0.256_022_66,
-0.660_268,
0.039_130_14,
-0.481_968_08,
-0.089_253_89,
-0.579_329_7,
],
vec![
0.670_172_63,
-0.580_271_24,
-0.649_096_13,
-0.474_525_66,
-0.377_117_63,
1.405_239_2,
-1.221_097_2,
1.200_569_9,
-0.086_327_35,
-2.255_320_3,
], |
vec![
-1.358_025_8,
-0.342_335_22,
0.295_178_5,
0.075_462_48,
-0.263_600_26,
-0.065_306_99,
-0.355_591_6,
-0.309_273_7,
0.027_559_858,
-0.708_983_06,
],
vec![
-0.110_825_61,
-0.441_783_8,
0.510_953,
-0.017_491_657,
-0.361_264_1,
-0.658_499_2,
-1.168_359,
-0.183_945_58,
-0.018_839_432,
0.259_778_83,
],
vec![
0.177_515_95,
-0.075_632_31,
0.013_366_969,
-0.259_934_54,
-0.146_670_1,
0.083_243_91,
-0.245_393_48,
-0.015_866_693,
-0.118_829_71,
-0.008_721_328,
],
vec![
-0.550_502_36,
0.540_914_7,
-0.971_661_1,
-0.326_274_57,
0.005_312_611_3,
-1.068_250_4,
0.266_432_85,
0.465_531_14,
-0.377_819_33,
-2.766_870_7,
],
vec![
0.389_952,
0.049_188_2,
-0.070_362_93,
-0.158_295_77,
-0.054_504_406,
-0.162_878_42,
-0.329_468_82,
0.147_300_17,
-0.285_775_2,
-0.423_477_32,
],
vec![
-0.437_943_52,
-0.068_380_67,
0.194_627_26,
0.281_447_74,
-0.220_649_88,
-0.678_889,
-0.277_028_77,
0.230_105_79,
-0.006_377_558_7,
-0.206_830_32,
],
vec![ |
-0.009_224_954,
-0.378_657,
-0.085_123_174,
-0.156_714_63,
-0.343_136_5,
0.055_030_156,
0.559_048_8,
-0.327_488_06,
0.169_883_4,
0.034_172_5,
],
vec![
-0.688_926_8,
-0.104_911_59,
-0.976_121_96,
-0.522_905_95,
0.565_652_97,
0.191_607_74,
0.928_987_7,
0.271_104_07,
-0.397_580_33,
-1.708_864_6,
],
vec![
0.012_301_554,
0.117_295_76,
-0.027_031_401,
0.264_092_45,
-0.886_667_85,
-0.591_631_6,
0.270_088_85,
0.682_763,
-0.278_033_26,
-0.395_845_86,
],
vec![
-0.342_501_8,
0.562_693_6,
0.067_982_31,
0.326_943_3,
-0.336_273_97,
-0.601_590_1,
-0.685_105_3,
0.369_405_27,
-0.058_104_467,
-0.033_579_066,
],
vec![
0.064_386_68,
-0.400_555_73,
-0.182_303_9,
-0.218_738_72,
0.216_905_34,
0.030_601_45,
0.094_936_07,
-0.009_266_577,
0.087_377_72,
0.053_116_817,
],
vec![
0.239_458_02,
-0.553_885_1,
-0.751_549_4,
-0.327_702_13,
0.808_595_7,
0.551_519_1,
0.284_371_67,
0.547_793_6,
-0.059_032_235,
-1.324_021_5,
],
vec![
-0.452_034_92, |
0.261_517_6,
-0.252_394_05,
0.092_079_16,
0.429_929_17,
-0.167_667_57,
-0.211_615_74,
0.671_054_8,
0.349_666_24,
-2.117_855,
],
vec![
-0.528_661_1,
-0.472_939_22,
0.182_015_09,
0.317_773_28,
-0.124_089_79,
0.045_638_64,
-0.724_232_9,
0.204_953_31,
-0.398_932_28,
0.107_951_67,
],
vec![
-0.052_959_226,
0.135_726_82,
-0.136_894_15,
-0.566_229_05,
0.380_288_6,
0.140_286_85,
0.135_775_07,
-0.249_593_62,
-0.017_248_28,
-0.027_598_498,
],
vec![
-0.220_504_76,
-0.046_495_143,
0.180_323_42,
-0.790_958_3,
1.322_335_2,
-0.108_043_14,
0.217_102_74,
0.825_262_4,
-0.492_108_76,
-0.700_494_5,
],
vec![
-0.352_748_78,
0.213_851_73,
-0.163_977_56,
0.404_177_84,
-0.249_681_82,
-0.216_996_63,
-0.862_111_8,
0.325_164_74,
-0.162_396_8,
-0.256_683_9,
],
vec![
-0.436_135_6,
-0.409_798_77,
-0.208_920_99,
0.172_075_72,
-0.236_797_62,
0.082_351_59,
-0.514_797_4,
0.356_074_42,
0.015_723_99,
-0.081_596_93,
],
vec![
-0.451_420_16,
0.285_002_02, |
-0.344_098_42,
-0.568_649_4,
0.139_230_56,
0.200_250_37,
0.495_893_72,
-0.290_844_05,
-0.022_031_482,
0.050_763_61,
],
vec![
-0.173_756_91,
0.419_162_12,
-0.180_732_7,
-0.057_678_43,
0.963_222_5,
-0.542_589_25,
-0.015_682_373,
0.089_011_23,
0.035_791_16,
-0.455_887_17,
],
vec![
-1.004_596_5,
-0.236_272_17,
0.173_167_3,
0.228_756_13,
0.258_503_44,
-0.065_365_806,
-0.879_822_5,
0.722_794_3,
-0.097_331_2,
-0.077_870_905,
],
vec![
0.234_086_29,
-0.009_919_475,
-0.074_891_225,
-0.144_583_54,
-0.535_934_6,
0.124_304_32,
-0.782_060_27,
0.254_513_5,
0.055_683_39,
0.069_254_84,
],
vec![
-0.390_705_17,
0.384_156_38,
-0.186_229_33,
-0.584_244_1,
0.531_919_96,
-0.069_686_66,
0.149_591_43,
-0.778_742_8,
-0.081_920_885,
-0.154_186_23,
],
vec![
-0.041_898_686,
0.129_092_99,
-0.216_378_45,
0.181_084_84,
0.883_805_04,
-0.262_621,
-0.308_502_35,
0.180_086_1,
-0.291_687_16,
-0.113_592_334,
],
vec![
-0.206_446_33,
0.171_964_9,
0.293_709_2, |
0.253_592_46,
-1.241_981_9,
-0.466_809_84,
-0.528_306_25,
0.566_160_56,
-0.294_850_35,
0.329_751_46,
],
vec![
0.028_156_348,
-0.089_827_4,
-0.039_944_68,
0.003_904_477_2,
-0.143_147_95,
-0.087_608_19,
-0.271_006_9,
0.135_168_46,
-0.169_262_14,
0.179_181,
],
vec![
-0.158_213_47,
0.260_261_42,
-0.499_890_12,
-0.617_226_6,
0.677_156,
-0.141_557_51,
-0.015_163_827,
-0.268_581_3,
-0.383_393_73,
-0.079_002_6,
],
vec![
0.025_213_772,
0.040_827_68,
-0.178_087_09,
0.116_391_845,
0.563_567_34,
-0.275_989_44,
-0.174_380_75,
-0.001_827_002_7,
0.125_746_6,
-0.340_517_07,
],
vec![
0.019_749_146,
-0.783_887_57,
0.526_380_2,
-0.228_184_16,
-0.979_208_3,
0.045_181_397,
-0.290_830_22,
0.281_862_97,
0.212_756_75,
0.077_207_305,
],
vec![
0.017_906_101,
-0.163_613_9,
0.087_164_72,
-0.046_330_657,
-0.222_235_14,
0.046_974_953,
-0.568_875_7,
0.137_390_6,
0.149_732_47,
0.054_858_174,
],
vec![
-0.142_019_9,
0.449_144_24,
-0.686_669_5,
-1.09 |
0_786_9,
0.604_686_6,
0.076_722_49,
0.245_582_54,
-0.829_804_2,
-0.165_203_63,
-0.149_007_14,
],
vec![
0.320_993_96,
0.119_689_37,
-0.150_012_6,
0.191_727_18,
0.082_919_58,
-0.527_837_1,
-0.071_530_03,
-0.021_497_987,
0.270_940_7,
-0.278_216_78,
],
vec![
0.283_085_38,
-1.443_256_5,
0.252_147_61,
-0.163_902_98,
-1.414_779_3,
0.236_899_23,
-0.015_835_924,
-0.211_199_78,
0.192_544_15,
0.535_805_1,
],
vec![
-0.031_128_181,
0.098_440_4,
-0.250_576_62,
0.001_446_956_2,
-0.166_310_09,
0.114_397_4,
-0.101_888_314,
0.048_192_31,
0.161_405_6,
0.090_395_294,
],
vec![
-0.724_360_1,
0.207_801_43,
-1.503_290_2,
-1.666_891_3,
0.339_504,
0.795_809_75,
0.389_212_52,
0.054_467_775,
-0.033_395_73,
-0.436_388_46,
],
vec![
0.075_730_63,
0.098_023_93,
-0.263_772_16,
-0.093_434_33,
0.315_961_48,
-0.366_490_3,
-0.232_862_79,
-0.119_057_89,
0.091_956_18,
-0.089_295_94,
],
vec![
-0.308_372_44,
-0.820_044_16,
-0.298_285_63,
-0.393_244_65,
-0 |
.718_027_65,
0.584_613_74,
0.539_996_6,
-1.438_904_9,
0.176_980_63,
0.054_312_26,
],
vec![
0.174_080_85,
-0.216_159_63,
-0.026_459_76,
-0.357_671_2,
-0.113_939_73,
0.013_583_492_5,
-0.351_176_86,
0.252_733_47,
-0.039_529_853,
0.268_498_1,
],
vec![
-1.993_145,
0.287_121_62,
-0.888_011_2,
-0.614_505_9,
0.438_744_78,
0.506_205_6,
0.087_504_11,
-0.068_988_88,
-0.123_064_6,
-1.331_926,
],
vec![
0.215_632_22,
0.129_511_37,
0.274_990_14,
0.122_623_39,
0.047_715_563,
-0.734_401_6,
-0.375_344_1,
-0.003_185_275_7,
0.057_150_718,
-0.352_097_4,
],
vec![
-0.425_337_6,
-0.582_686,
-1.584_758_6,
-0.888_137_8,
-0.990_626_6,
0.632_610_14,
0.343_601_02,
-0.343_171_48,
0.222_747_77,
0.065_007_046,
],
vec![
0.751_865_74,
0.084_619_09,
-0.242_130_18,
-0.014_619_584,
-0.288_201_75,
-0.035_856_392,
-0.978_297_7,
-0.108_465_13,
0.110_781_03,
0.192_797_72,
],
vec![
0.273_850_1,
-0.150_658_67,
0.348_599_05,
-1.558_001_3,
0.530_314_56,
0.911 |
_728_44,
-0.471_142_77,
-1.818_102_1,
-0.112_300_32,
-4.107_308_4,
],
vec![
0.576_481_4,
0.174_494_85,
0.100_200_04,
0.411_519_68,
0.186_069_13,
-0.563_864_1,
-0.216_897_5,
-0.346_323_73,
-0.215_137_65,
-0.052_019_272,
],
vec![
-0.467_293_86,
-0.549_939_3,
-1.342_918_4,
-1.506_654_6,
0.483_067_24,
0.573_365,
0.154_416_11,
-1.015_882_1,
0.205_112_19,
-2.852_063_4,
],
vec![
0.213_581_4,
-1.916_046_5,
-0.781_541_6,
0.128_297_82,
0.124_022_01,
0.193_614_44,
-1.000_155_4,
0.545_728,
-0.012_136_586,
-0.500_476_4,
],
vec![
-0.691_628_8,
-0.228_353_02,
0.110_913_61,
0.106_528_59,
-0.173_485_19,
-0.040_805_902,
0.203_944_06,
-0.366_668_88,
0.147_183_84,
-0.490_145_03,
],
vec![
0.456_025_42,
-0.025_084_412,
-0.650_509_3,
0.048_621_442,
0.065_681_994,
-0.435_010_22,
-0.478_657_13,
0.297_409_1,
-2.209_085_7,
-2.428_078,
],
vec![
-0.779_053_87,
-0.167_990_27,
0.034_315_918,
0.144_756_27,
-0.375_923_57,
-0.178_410_22,
0.417_126_ |
63,
-0.057_014_92,
0.045_673_035,
-0.833_929_9,
],
vec![
-0.359_902_32,
-0.453_145_5,
0.376_054_2,
0.005_921_751,
-0.402_688_4,
-0.281_222_13,
-0.328_012,
0.300_563_34,
-0.322_811_7,
-0.074_488_41,
],
vec![
0.155_242_74,
-0.326_161_83,
-0.004_502_223,
0.111_678_13,
-0.222_018,
0.012_103_265,
-0.348_285_56,
-0.313_547_67,
-0.090_373_31,
0.160_877_32,
],
vec![
-0.779_235_84,
0.474_958_9,
0.174_592_91,
-0.627_929_2,
0.143_707_56,
0.655_198_63,
0.920_332_2,
-1.552_636_5,
-1.044_534_9,
-0.399_366_97,
],
vec![
0.396_845_64,
-0.116_464_78,
-0.188_253_75,
0.055_635_884,
-0.439_850_36,
-0.115_104_504,
-0.056_754_448,
0.037_380_192,
0.050_991_777,
0.002_617_539_4,
],
vec![
-0.062_194_28,
-0.033_647_98,
0.563_151_8,
0.341_664_5,
-0.104_682_36,
-1.025_237_4,
-0.539_365_8,
-0.000_981_343_2,
-0.223_044_22,
-0.168_867_19,
],
vec![
0.034_815_1,
-0.044_562_746,
0.251_306_33,
-0.103_972_74,
-0.293_429,
-0.159_355_21,
0.462_565_1,
-0 |
.656_678_1,
-0.184_929_68,
0.138_410_73,
],
vec![
-0.174_431,
-1.836_079_8,
-0.516_358_14,
-0.740_650_9,
0.628_450_63,
0.170_128_93,
0.793_973_86,
0.020_685_973,
0.408_096_08,
-0.257_820_37,
],
vec![
0.114_661_67,
-0.360_247,
-0.330_312_13,
0.139_972_79,
0.192_194_07,
0.278_673_35,
0.177_378_13,
0.021_838_47,
-0.169_735_85,
-0.255_217_5,
],
vec![
0.028_787_855,
0.378_440_35,
0.000_291_143_08,
0.002_877_849_9,
-0.058_781_974,
-0.380_325_88,
-0.472_144_9,
0.718_679_3,
-0.138_149_2,
-0.280_253_98,
],
vec![
-0.207_616_76,
-0.588_388_74,
0.261_936_13,
0.095_424_83,
0.073_274_486,
-0.358_869_7,
0.323_256_52,
-0.497_251_27,
0.098_571_09,
0.244_916_02,
],
vec![
-0.053_375_665,
-0.907_372,
-0.727_244_5,
-0.735_421_36,
1.110_396_5,
-0.135_271_1,
0.323_004_5,
-0.285_868_73,
0.309_256_9,
0.093_485_77,
],
vec![
0.084_668_264,
-0.228_887_29,
-0.118_540_026,
-0.044_351_313,
-0.233_455_63,
0.082_216_516,
-0.374_227_14,
-0.009_539_394, |
0.398_557_2,
-0.049_398_433,
],
vec![
-0.263_275_8,
-0.310_658_13,
-0.045_278_024,
0.538_273_16,
-0.228_020_5,
-0.319_284_53,
-0.379_847_7,
0.403_462,
0.080_615_55,
-0.393_287,
],
vec![
0.068_945_13,
-0.858_146_67,
0.032_959_49,
-0.034_787_893,
0.424_780_7,
-0.216_492_3,
0.112_251_35,
-0.547_673_2,
0.084_244_326,
0.356_082_77,
],
vec![
0.270_711_66,
-0.755_480_23,
-0.261_522_35,
-0.893_010_74,
0.546_178_9,
0.567_656_6,
0.107_416_8,
0.016_729_54,
0.054_772_306,
-0.339_417_46,
],
vec![
-0.102_297_716,
-0.127_307_89,
0.000_735_883_37,
0.086_636_01,
-0.433_231_8,
-0.243_996_05,
-0.712_842_9,
0.360_887_5,
0.110_613_66,
0.189_828_68,
],
vec![
-0.059_796_482,
-0.650_247_5,
0.098_926_224,
-0.024_830_63,
-0.814_044_24,
-0.161_119_15,
-0.094_905_17,
0.543_763_4,
0.024_063_092,
0.069_586_42,
],
vec![
-0.213_605_99,
-0.365_503_8,
-0.127_580_96,
-0.113_292_836,
0.228_936_3,
-0.064_502_29,
0.331_887_63,
-0.558_377,
-0.105_677_84, |
0.444_680_2,
],
vec![
0.092_395_35,
-0.757_139_86,
-0.181_506_59,
-0.323_408_84,
0.503_436_9,
0.635_710_5,
0.275_355_67,
-0.271_641_22,
-0.356_673_75,
-0.198_984_77,
],
vec![
-0.320_055_9,
-0.051_496_968,
0.210_841_16,
0.095_058_99,
-0.900_580_4,
-0.156_174_99,
-0.703_600_94,
0.193_674_56,
0.199_007_3,
0.074_151_62,
],
vec![
-0.013_607_603_5,
-0.190_512_06,
-0.122_698_225,
-0.009_026_426,
-0.540_006_04,
0.150_625_72,
-0.424_062_43,
0.269_272_54,
0.120_677_96,
-0.155_426_44,
],
vec![
-0.143_616_9,
0.148_102_3,
-0.157_922_39,
-0.248_577_13,
0.257_107_26,
-0.471_419,
0.425_645_65,
0.091_029_1,
-0.133_166_4,
-0.123_961_67,
],
vec![
0.433_771_67,
0.247_506_9,
0.264_603_5,
-0.381_750_3,
0.335_878_8,
-0.245_618_85,
-0.068_682_83,
-0.399_691_46,
0.022_163_01,
-0.154_636_74,
],
vec![
-0.236_952_07,
-0.070_704_85,
0.307_582,
0.150_636_15,
-1.261_24,
-0.333_410_05,
-0.273_555_9,
0.428_589_14,
0.090_926_83,
0.019_844_66,
], |
vec![
0.111_911_74,
-0.250_866_5,
-0.040_530_857,
-0.009_811_868,
-0.376_664_34,
0.104_442_65,
0.236_929_12,
0.013_377_204,
-0.148_502_3,
-0.034_420_002,
],
vec![
-0.591_157_1,
0.354_086_85,
-0.014_166_484,
-0.011_582_683,
0.490_577_4,
-1.111_166_6,
-0.253_583_64,
0.226_966_57,
-0.246_680_5,
-0.316_616_7,
],
vec![
0.504_683_3,
0.082_675_785,
0.287_152_26,
-0.142_236_1,
0.190_242_7,
-0.515_907_8,
-0.559_472_44,
0.154_153_21,
-0.010_323_325,
-0.047_526_196,
],
vec![
0.040_378_43,
-0.571_260_6,
0.326_861_7,
-0.038_053_866,
-0.517_120_9,
-0.016_231_31,
0.090_821_356,
0.315_481_07,
-0.096_167_43,
0.083_659_82,
],
vec![
0.171_835_9,
-0.296_782_73,
-0.215_916_13,
-0.310_014_22,
-0.178_923_47,
0.281_085_5,
0.054_179_72,
0.038_410_88,
0.157_684_07,
0.010_856_905,
],
vec![
-0.762_344_84,
-0.197_173_1,
-0.075_202_31,
0.061_614_38,
0.914_948_6,
-0.605_976,
-0.187_276_05,
0.057_749_826,
-0.446_927_88,
-0.033_777_487,
],
vec![ |
0.233_660_5,
0.015_873_462,
-0.005_255_001,
-0.047_930_67,
0.257_369_7,
-0.254_187_23,
-0.628_627_66,
0.188_018_29,
0.055_216_342,
0.058_550_056,
],
vec![
0.334_796_16,
-1.575_294_3,
-0.049_017_817,
0.073_439_24,
-1.058_597_1,
0.562_272_2,
0.137_210_01,
-0.083_788_86,
-0.103_471_24,
0.205_879_26,
],
vec![
0.152_744_38,
-0.078_858_71,
-0.300_489_6,
-0.508_556_37,
-0.266_207_28,
0.130_250_9,
-0.039_310_664,
0.147_595_6,
-0.039_225_88,
0.196_362_9,
],
vec![
-0.866_875_9,
-0.032_697_26,
-0.008_656_468,
0.190_088_78,
0.596_259_3,
-0.330_446_96,
-0.226_081_36,
0.625_718_9,
-0.563_011_1,
-0.301_735_8,
],
vec![
0.189_101_77,
0.056_929_618,
0.103_171_59,
0.099_822_3,
-0.248_609_11,
-0.085_192_98,
-0.267_723_77,
0.317_740_5,
-0.030_244_146,
-0.082_437_694,
],
vec![
0.031_138_998,
-1.029_084_6,
-0.341_533_42,
-0.254_793_05,
-1.071_284_2,
0.558_588_2,
0.475_417_94,
-0.036_093_22,
0.231_615_5,
-0.322_770_45,
],
vec![
0.206_510_78, |
-0.975_108_86,
-0.343_907_36,
-0.275_595_87,
0.108_924_91,
-0.082_869_17,
0.311_547_16,
0.140_963_84,
0.180_081_08,
0.021_928_212,
],
vec![
-1.792_503,
0.350_376_55,
-0.283_779_7,
0.281_561_2,
0.248_667_24,
0.750_453_65,
-0.240_568_13,
0.259_737_46,
-0.099_345_72,
-1.129_956_1,
],
vec![
0.298_311,
0.325_646_67,
0.058_641_44,
0.327_485_47,
-0.216_788_63,
-0.641_922_06,
-0.490_922_72,
0.229_161_78,
-0.169_965_76,
0.082_617_49,
],
vec![
-0.676_340_46,
-0.086_615_1,
-0.990_129_9,
-0.964_055_06,
-0.247_590_47,
0.553_486_35,
0.752_743_9,
-0.568_961_1,
0.076_329_686,
0.269_663_78,
],
vec![
0.300_149_08,
0.034_903_92,
-0.273_156_73,
0.056_118_354,
-0.397_347_72,
0.280_960_4,
-0.701_381_3,
0.309_347_1,
-0.070_615_38,
-0.147_566_08,
],
vec![
-1.512_842_3,
0.122_137_405,
-0.179_424_73,
-0.621_348_2,
0.242_645_67,
0.254_495_02,
0.367_945_88,
1.093_051_2,
-0.087_014_63,
-1.320_766_2,
],
vec![
0.542_720_8,
0.077_151_79, |
-0.531_274_4,
-0.059_125_736,
0.000_248_613_5,
-0.136_497_18,
-0.709_108_35,
-0.274_145_84,
0.022_545_459,
0.260_933_85,
],
vec![
-0.764_393_57,
-0.922_812_3,
-0.821_932_6,
-0.524_062_63,
0.694_806_46,
0.568_482_94,
0.471_779_05,
-0.350_464_94,
-0.237_650_19,
-0.299_388_14,
],
vec![
0.166_719_18,
-0.987_571_95,
-0.263_751_92,
-0.581_680_95,
-0.483_688_56,
-0.518_314,
-1.389_688_4,
0.515_866_94,
0.115_079_865,
-0.318_235_1,
],
vec![
-0.271_017_07,
0.027_525_388,
-0.597_32,
-0.095_019_13,
-0.346_175_88,
0.580_207_8,
0.300_787_75,
0.043_705_73,
0.192_469_06,
-0.462_464,
],
vec![
-0.096_515_015,
0.289_297_34,
-0.863_468_95,
1.005_157_8,
0.689_947_84,
-1.832_172_2,
-0.294_198_7,
-0.983_701_9,
-2.073_236_5,
0.231_339_78,
],
vec![
-0.207_874_55,
0.057_534_594,
0.094_972_5,
-0.265_003_83,
-0.204_895_66,
0.182_718_59,
0.165_258_41,
-0.206_470_95,
0.043_471_36,
-0.343_006_22,
],
vec![
-0.508_934_4,
0.487_504_9,
0.623_735_13, |
0.645_485_3,
0.305_668_68,
-1.129_35,
0.055_277_206,
-0.114_775_866,
0.181_829_91,
-0.267_725_83,
],
vec![
0.226_889_83,
-0.029_484_963,
0.074_473_15,
-0.288_940_55,
-0.178_996_61,
-0.191_890_85,
-0.276_085_3,
-0.236_703_66,
0.093_048_16,
0.225_298_88,
],
vec![
0.153_564_24,
0.594_082_36,
-1.309_799_2,
-0.612_569_87,
-0.765_506_86,
-0.534_287_15,
0.528_604_87,
-1.124_329_4,
0.193_627_3,
0.739_874_84,
],
vec![
0.515_318_45,
-0.407_639_27,
0.022_146_78,
-0.034_811_374,
-0.463_529_68,
0.219_874_3,
-0.065_351_21,
-0.027_115_954,
-0.071_082_34,
-0.167_560_82,
],
vec![
-0.603_041_3,
0.173_094_06,
0.762_386_4,
0.372_296_84,
0.222_196_31,
-0.495_753_3,
-0.050_564_97,
0.188_722_49,
-0.672_652_3,
-0.178_792_94,
],
vec![
-0.007_911_94,
-0.482_079_4,
-0.032_675_47,
0.100_052_4,
0.052_513_74,
-0.225_124_18,
0.350_639_73,
-0.364_823_76,
-0.068_803_236,
0.187_773_08,
],
vec![
-0.062_913_46,
-0.409_758,
-0.320_442_44,
-0.662_729_5, |
0.509_824_34,
-0.360_478_6,
0.261_233_48,
-0.390_644_28,
0.279_211_82,
0.240_606_68,
],
vec![
0.160_814_46,
-0.166_563_53,
-0.262_935_88,
-0.128_298,
0.155_533_05,
0.059_555_724,
0.234_794_65,
-0.034_388_43,
-0.145_194_62,
-0.093_202_814,
],
vec![
-0.473_849_77,
0.157_912_72,
0.307_175_3,
-0.267_877_85,
-0.035_855_27,
-0.207_699_18,
-0.755_759_1,
0.950_489_8,
-0.056_404_267,
-0.497_116_45,
],
vec![
-0.107_620_25,
-0.324_108_27,
0.029_556_079,
0.184_373_11,
0.007_395_293,
-0.526_876_57,
0.440_726_82,
-0.351_558_86,
-0.289_385_68,
0.304_280_7,
],
vec![
0.286_830_5,
-0.225_128_16,
-0.789_902_45,
-0.810_649_3,
0.174_392_4,
0.465_826_45,
0.181_955_62,
-0.288_959_44,
0.213_181_47,
0.089_912,
],
vec![
-0.127_923_15,
0.353_413_67,
-0.127_158_69,
0.096_508_25,
-0.535_945_6,
-0.188_380_03,
-0.068_326_57,
-0.082_721_69,
0.070_878_4,
0.082_282_38,
],
vec![
-0.180_664_45,
-0.405_656_93,
-0.136_641_98,
0.076_221_325,
0.185_186_62, |
-0.130_355_78,
-0.347_225_52,
0.435_685_66,
-0.321_748_17,
-0.309_609_06,
],
vec![
-0.100_575_75,
-0.154_703_74,
-0.374_440_88,
0.506_969_3,
0.237_276_14,
-0.406_840_98,
0.281_832_3,
-0.290_095_18,
-0.199_270_83,
0.243_440_67,
],
vec![
0.221_755_46,
-0.790_980_94,
-0.791_633_2,
-0.824_782_43,
0.527_411_8,
0.514_031_65,
-0.120_601_065,
0.260_423_42,
0.167_460_32,
0.026_457_088,
],
vec![
0.109_922_58,
0.160_769_25,
-0.222_593_46,
-0.154_723_23,
-0.093_943_31,
0.204_556_7,
-0.885_124_86,
0.142_079_01,
-0.057_717_92,
0.302_287_22,
],
vec![
-0.424_106_03,
-0.129_682_73,
-0.087_105_61,
0.066_099_56,
-0.148_481_16,
-0.041_067_887,
-0.416_681_7,
0.047_628_727,
0.078_313_41,
0.058_919_758,
],
vec![
0.083_984_82,
-0.395_945_52,
-0.220_289_78,
0.432_484_95,
0.357_147_13,
-0.226_951_78,
0.522_340_24,
-0.679_507_1,
-0.194_740_58,
0.244_101_08,
],
vec![
0.102_482_185,
-0.045_399_34,
-0.080_852_3,
-1.222_988,
0.312_472_9,
0.321_611 |
_9,
-0.034_010_515,
0.186_449_16,
0.316_959_83,
-0.126_345_13,
],
vec![
-0.429_622_08,
0.161_493_81,
0.117_336_29,
0.354_605_3,
-0.120_046_5,
-0.057_381_7,
-0.986_256_5,
-0.148_423_24,
0.157_069_16,
-0.052_750_13,
],
vec![
-0.529_666_66,
-0.341_064_48,
-0.274_165_27,
-0.241_169_75,
-0.250_266_55,
0.153_471_22,
0.504_053_7,
0.009_148_11,
0.325_742_24,
-0.271_160_96,
],
vec![
-0.219_010_8,
0.314_067_42,
-0.029_913_263,
0.225_025_37,
0.235_776_56,
-0.426_587_97,
0.019_475_369,
-0.328_953_74,
-0.212_118_6,
-0.039_429_653,
],
vec![
0.143_026_13,
0.481_122_58,
0.000_815_544_16,
-0.512_762_4,
0.290_940_82,
-0.322_919_73,
-0.410_684_62,
0.214_782_43,
0.438_849_93,
-0.633_576_15,
],
vec![
-0.262_988_4,
0.058_395_483,
0.047_117_49,
0.129_354_98,
-0.311_606_05,
-0.030_636_294,
-0.587_008_95,
0.526_908_46,
-0.221_597_34,
-0.057_889_156,
],
vec![
-0.420_213_37,
0.063_557_32,
-0.267_797_08,
-0.124_470_5,
-0.566_938_64,
0.322_641_5, |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.