barretenberg
Loading...
Searching...
No Matches
AvmMini_flavor.hpp
1
2
3#pragma once
4#include "../relation_definitions_fwd.hpp"
5#include "barretenberg/commitment_schemes/kzg/kzg.hpp"
6#include "barretenberg/ecc/curves/bn254/g1.hpp"
7#include "barretenberg/polynomials/barycentric.hpp"
8#include "barretenberg/polynomials/univariate.hpp"
9
10#include "barretenberg/flavor/flavor.hpp"
11#include "barretenberg/flavor/flavor_macros.hpp"
12#include "barretenberg/polynomials/evaluation_domain.hpp"
13#include "barretenberg/polynomials/polynomial.hpp"
14#include "barretenberg/relations/generated/AvmMini/avm_mini.hpp"
15#include "barretenberg/relations/generated/AvmMini/mem_trace.hpp"
16#include "barretenberg/transcript/transcript.hpp"
17
18namespace proof_system::honk {
19namespace flavor {
20
21class AvmMiniFlavor {
22 public:
23 using Curve = curve::BN254;
24 using G1 = Curve::Group;
25 using PCS = pcs::kzg::KZG<Curve>;
26
27 using FF = G1::subgroup_field;
28 using Polynomial = barretenberg::Polynomial<FF>;
29 using PolynomialHandle = std::span<FF>;
30 using GroupElement = G1::element;
31 using Commitment = G1::affine_element;
32 using CommitmentHandle = G1::affine_element;
33 using CommitmentKey = pcs::CommitmentKey<Curve>;
34 using VerifierCommitmentKey = pcs::VerifierCommitmentKey<Curve>;
35
36 static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2;
37 static constexpr size_t NUM_WITNESS_ENTITIES = 20;
38 static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES;
39 // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for
40 // the unshifted and one for the shifted
41 static constexpr size_t NUM_ALL_ENTITIES = 25;
42
43 using Relations = std::tuple<AvmMini_vm::avm_mini<FF>, AvmMini_vm::mem_trace<FF>>;
44
45 static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length<Relations>();
46
47 // BATCHED_RELATION_PARTIAL_LENGTH = algebraic degree of sumcheck relation *after* multiplying by the `pow_zeta`
48 // random polynomial e.g. For \sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation
49 // length = 3
50 static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1;
51 static constexpr size_t NUM_RELATIONS = std::tuple_size<Relations>::value;
52
53 template <size_t NUM_INSTANCES>
54 using ProtogalaxyTupleOfTuplesOfUnivariates =
55 decltype(create_protogalaxy_tuple_of_tuples_of_univariates<Relations, NUM_INSTANCES>());
56 using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
57 using TupleOfArraysOfValues = decltype(create_tuple_of_arrays_of_values<Relations>());
58
59 static constexpr bool has_zero_row = true;
60
61 private:
62 template <typename DataType_> class PrecomputedEntities : public PrecomputedEntitiesBase {
63 public:
64 using DataType = DataType_;
65
66 DEFINE_FLAVOR_MEMBERS(DataType, avmMini_clk, avmMini_first)
67
68 RefVector<DataType> get_selectors()
69 {
70 return {
71 avmMini_clk,
72 avmMini_first,
73 };
74 };
75
76 RefVector<DataType> get_sigma_polynomials() { return {}; };
77 RefVector<DataType> get_id_polynomials() { return {}; };
78 RefVector<DataType> get_table_polynomials() { return {}; };
79 };
80
81 template <typename DataType> class WitnessEntities {
82 public:
83 DEFINE_FLAVOR_MEMBERS(DataType,
84 memTrace_m_clk,
85 memTrace_m_sub_clk,
86 memTrace_m_addr,
87 memTrace_m_val,
88 memTrace_m_lastAccess,
89 memTrace_m_rw,
90 avmMini_subop,
91 avmMini_ia,
92 avmMini_ib,
93 avmMini_ic,
94 avmMini_mem_op_a,
95 avmMini_mem_op_b,
96 avmMini_mem_op_c,
97 avmMini_rwa,
98 avmMini_rwb,
99 avmMini_rwc,
100 avmMini_mem_idx_a,
101 avmMini_mem_idx_b,
102 avmMini_mem_idx_c,
103 avmMini_last)
104
105 RefVector<DataType> get_wires()
106 {
107 return {
108 memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, memTrace_m_val, memTrace_m_lastAccess,
109 memTrace_m_rw, avmMini_subop, avmMini_ia, avmMini_ib, avmMini_ic,
110 avmMini_mem_op_a, avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, avmMini_rwb,
111 avmMini_rwc, avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last,
112
113 };
114 };
115
116 RefVector<DataType> get_sorted_polynomials() { return {}; };
117 };
118
119 template <typename DataType> class AllEntities {
120 public:
121 DEFINE_FLAVOR_MEMBERS(DataType,
122 avmMini_clk,
123 avmMini_first,
124 memTrace_m_clk,
125 memTrace_m_sub_clk,
126 memTrace_m_addr,
127 memTrace_m_val,
128 memTrace_m_lastAccess,
129 memTrace_m_rw,
130 avmMini_subop,
131 avmMini_ia,
132 avmMini_ib,
133 avmMini_ic,
134 avmMini_mem_op_a,
135 avmMini_mem_op_b,
136 avmMini_mem_op_c,
137 avmMini_rwa,
138 avmMini_rwb,
139 avmMini_rwc,
140 avmMini_mem_idx_a,
141 avmMini_mem_idx_b,
142 avmMini_mem_idx_c,
143 avmMini_last,
144 memTrace_m_rw_shift,
145 memTrace_m_addr_shift,
146 memTrace_m_val_shift)
147
148 RefVector<DataType> get_wires()
149 {
150 return {
151 avmMini_clk,
152 avmMini_first,
153 memTrace_m_clk,
154 memTrace_m_sub_clk,
155 memTrace_m_addr,
156 memTrace_m_val,
157 memTrace_m_lastAccess,
158 memTrace_m_rw,
159 avmMini_subop,
160 avmMini_ia,
161 avmMini_ib,
162 avmMini_ic,
163 avmMini_mem_op_a,
164 avmMini_mem_op_b,
165 avmMini_mem_op_c,
166 avmMini_rwa,
167 avmMini_rwb,
168 avmMini_rwc,
169 avmMini_mem_idx_a,
170 avmMini_mem_idx_b,
171 avmMini_mem_idx_c,
172 avmMini_last,
173 memTrace_m_rw_shift,
174 memTrace_m_addr_shift,
175 memTrace_m_val_shift,
176
177 };
178 };
179
180 RefVector<DataType> get_unshifted()
181 {
182 return {
183 avmMini_clk,
184 avmMini_first,
185 memTrace_m_clk,
186 memTrace_m_sub_clk,
187 memTrace_m_addr,
188 memTrace_m_val,
189 memTrace_m_lastAccess,
190 memTrace_m_rw,
191 avmMini_subop,
192 avmMini_ia,
193 avmMini_ib,
194 avmMini_ic,
195 avmMini_mem_op_a,
196 avmMini_mem_op_b,
197 avmMini_mem_op_c,
198 avmMini_rwa,
199 avmMini_rwb,
200 avmMini_rwc,
201 avmMini_mem_idx_a,
202 avmMini_mem_idx_b,
203 avmMini_mem_idx_c,
204 avmMini_last,
205
206 };
207 };
208
209 RefVector<DataType> get_to_be_shifted()
210 {
211 return {
212 memTrace_m_rw,
213 memTrace_m_addr,
214 memTrace_m_val,
215
216 };
217 };
218
219 RefVector<DataType> get_shifted()
220 {
221 return {
222 memTrace_m_rw_shift,
223 memTrace_m_addr_shift,
224 memTrace_m_val_shift,
225
226 };
227 };
228 };
229
230 public:
231 class ProvingKey : public ProvingKey_<PrecomputedEntities<Polynomial>, WitnessEntities<Polynomial>> {
232 public:
233 // Expose constructors on the base class
234 using Base = ProvingKey_<PrecomputedEntities<Polynomial>, WitnessEntities<Polynomial>>;
235 using Base::Base;
236
237 RefVector<DataType> get_to_be_shifted()
238 {
239 return {
240 memTrace_m_rw,
241 memTrace_m_addr,
242 memTrace_m_val,
243
244 };
245 };
246 // The plookup wires that store plookup read data.
247 std::array<PolynomialHandle, 0> get_table_column_wires() { return {}; };
248 };
249
250 using VerificationKey = VerificationKey_<PrecomputedEntities<Commitment>>;
251
252 using FoldedPolynomials = AllEntities<std::vector<FF>>;
253
254 class AllValues : public AllEntities<FF> {
255 public:
256 using Base = AllEntities<FF>;
257 using Base::Base;
258 };
259
263 class ProverPolynomials : public AllEntities<Polynomial> {
264 public:
265 // Define all operations as default, except move construction/assignment
266 ProverPolynomials() = default;
267 ProverPolynomials& operator=(const ProverPolynomials&) = delete;
268 ProverPolynomials(const ProverPolynomials& o) = delete;
269 ProverPolynomials(ProverPolynomials&& o) noexcept = default;
270 ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default;
271 ~ProverPolynomials() = default;
272 [[nodiscard]] size_t get_polynomial_size() const { return avmMini_clk.size(); }
277 [[nodiscard]] AllValues get_row(size_t row_idx) const
278 {
279 AllValues result;
280 for (auto [result_field, polynomial] : zip_view(result.get_all(), this->get_all())) {
281 result_field = polynomial[row_idx];
282 }
283 return result;
284 }
285 };
286 using RowPolynomials = AllEntities<FF>;
287
288 class PartiallyEvaluatedMultivariates : public AllEntities<Polynomial> {
289 public:
290 PartiallyEvaluatedMultivariates() = default;
291 PartiallyEvaluatedMultivariates(const size_t circuit_size)
292 {
293 // Storage is only needed after the first partial evaluation, hence polynomials of size (n / 2)
294 for (auto& poly : get_all()) {
295 poly = Polynomial(circuit_size / 2);
296 }
297 }
298 };
299
304 template <size_t LENGTH> using ProverUnivariates = AllEntities<barretenberg::Univariate<FF, LENGTH>>;
305
309 using ExtendedEdges = ProverUnivariates<MAX_PARTIAL_RELATION_LENGTH>;
310
311 class CommitmentLabels : public AllEntities<std::string> {
312 private:
313 using Base = AllEntities<std::string>;
314
315 public:
316 CommitmentLabels()
317 : AllEntities<std::string>()
318 {
319 Base::avmMini_clk = "avmMini_clk";
320 Base::avmMini_first = "avmMini_first";
321 Base::memTrace_m_clk = "memTrace_m_clk";
322 Base::memTrace_m_sub_clk = "memTrace_m_sub_clk";
323 Base::memTrace_m_addr = "memTrace_m_addr";
324 Base::memTrace_m_val = "memTrace_m_val";
325 Base::memTrace_m_lastAccess = "memTrace_m_lastAccess";
326 Base::memTrace_m_rw = "memTrace_m_rw";
327 Base::avmMini_subop = "avmMini_subop";
328 Base::avmMini_ia = "avmMini_ia";
329 Base::avmMini_ib = "avmMini_ib";
330 Base::avmMini_ic = "avmMini_ic";
331 Base::avmMini_mem_op_a = "avmMini_mem_op_a";
332 Base::avmMini_mem_op_b = "avmMini_mem_op_b";
333 Base::avmMini_mem_op_c = "avmMini_mem_op_c";
334 Base::avmMini_rwa = "avmMini_rwa";
335 Base::avmMini_rwb = "avmMini_rwb";
336 Base::avmMini_rwc = "avmMini_rwc";
337 Base::avmMini_mem_idx_a = "avmMini_mem_idx_a";
338 Base::avmMini_mem_idx_b = "avmMini_mem_idx_b";
339 Base::avmMini_mem_idx_c = "avmMini_mem_idx_c";
340 Base::avmMini_last = "avmMini_last";
341 };
342 };
343
344 class VerifierCommitments : public AllEntities<Commitment> {
345 private:
346 using Base = AllEntities<Commitment>;
347
348 public:
349 VerifierCommitments(const std::shared_ptr<VerificationKey>& verification_key)
350 {
351 avmMini_clk = verification_key->avmMini_clk;
352 avmMini_first = verification_key->avmMini_first;
353 }
354 };
355
356 class Transcript : public BaseTranscript {
357 public:
358 uint32_t circuit_size;
359
360 Commitment memTrace_m_clk;
361 Commitment memTrace_m_sub_clk;
362 Commitment memTrace_m_addr;
363 Commitment memTrace_m_val;
364 Commitment memTrace_m_lastAccess;
365 Commitment memTrace_m_rw;
366 Commitment avmMini_subop;
367 Commitment avmMini_ia;
368 Commitment avmMini_ib;
369 Commitment avmMini_ic;
370 Commitment avmMini_mem_op_a;
371 Commitment avmMini_mem_op_b;
372 Commitment avmMini_mem_op_c;
373 Commitment avmMini_rwa;
374 Commitment avmMini_rwb;
375 Commitment avmMini_rwc;
376 Commitment avmMini_mem_idx_a;
377 Commitment avmMini_mem_idx_b;
378 Commitment avmMini_mem_idx_c;
379 Commitment avmMini_last;
380
381 std::vector<barretenberg::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>> sumcheck_univariates;
382 std::array<FF, NUM_ALL_ENTITIES> sumcheck_evaluations;
383 std::vector<Commitment> zm_cq_comms;
384 Commitment zm_cq_comm;
385 Commitment zm_pi_comm;
386
387 Transcript() = default;
388
389 Transcript(const std::vector<uint8_t>& proof)
390 : BaseTranscript(proof)
391 {}
392
393 void deserialize_full_transcript()
394 {
395 size_t num_bytes_read = 0;
396 circuit_size = deserialize_from_buffer<uint32_t>(proof_data, num_bytes_read);
397 size_t log_n = numeric::get_msb(circuit_size);
398
399 memTrace_m_clk = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
400 memTrace_m_sub_clk = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
401 memTrace_m_addr = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
402 memTrace_m_val = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
403 memTrace_m_lastAccess = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
404 memTrace_m_rw = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
405 avmMini_subop = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
406 avmMini_ia = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
407 avmMini_ib = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
408 avmMini_ic = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
409 avmMini_mem_op_a = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
410 avmMini_mem_op_b = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
411 avmMini_mem_op_c = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
412 avmMini_rwa = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
413 avmMini_rwb = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
414 avmMini_rwc = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
415 avmMini_mem_idx_a = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
416 avmMini_mem_idx_b = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
417 avmMini_mem_idx_c = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
418 avmMini_last = deserialize_from_buffer<Commitment>(Transcript::proof_data, num_bytes_read);
419
420 for (size_t i = 0; i < log_n; ++i) {
421 sumcheck_univariates.emplace_back(
422 deserialize_from_buffer<barretenberg::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>>(
423 Transcript::proof_data, num_bytes_read));
424 }
425 sumcheck_evaluations =
426 deserialize_from_buffer<std::array<FF, NUM_ALL_ENTITIES>>(Transcript::proof_data, num_bytes_read);
427 for (size_t i = 0; i < log_n; ++i) {
428 zm_cq_comms.push_back(deserialize_from_buffer<Commitment>(proof_data, num_bytes_read));
429 }
430 zm_cq_comm = deserialize_from_buffer<Commitment>(proof_data, num_bytes_read);
431 zm_pi_comm = deserialize_from_buffer<Commitment>(proof_data, num_bytes_read);
432 }
433
434 void serialize_full_transcript()
435 {
436 size_t old_proof_length = proof_data.size();
437 Transcript::proof_data.clear();
438 size_t log_n = numeric::get_msb(circuit_size);
439
440 serialize_to_buffer(circuit_size, Transcript::proof_data);
441
442 serialize_to_buffer<Commitment>(memTrace_m_clk, Transcript::proof_data);
443 serialize_to_buffer<Commitment>(memTrace_m_sub_clk, Transcript::proof_data);
444 serialize_to_buffer<Commitment>(memTrace_m_addr, Transcript::proof_data);
445 serialize_to_buffer<Commitment>(memTrace_m_val, Transcript::proof_data);
446 serialize_to_buffer<Commitment>(memTrace_m_lastAccess, Transcript::proof_data);
447 serialize_to_buffer<Commitment>(memTrace_m_rw, Transcript::proof_data);
448 serialize_to_buffer<Commitment>(avmMini_subop, Transcript::proof_data);
449 serialize_to_buffer<Commitment>(avmMini_ia, Transcript::proof_data);
450 serialize_to_buffer<Commitment>(avmMini_ib, Transcript::proof_data);
451 serialize_to_buffer<Commitment>(avmMini_ic, Transcript::proof_data);
452 serialize_to_buffer<Commitment>(avmMini_mem_op_a, Transcript::proof_data);
453 serialize_to_buffer<Commitment>(avmMini_mem_op_b, Transcript::proof_data);
454 serialize_to_buffer<Commitment>(avmMini_mem_op_c, Transcript::proof_data);
455 serialize_to_buffer<Commitment>(avmMini_rwa, Transcript::proof_data);
456 serialize_to_buffer<Commitment>(avmMini_rwb, Transcript::proof_data);
457 serialize_to_buffer<Commitment>(avmMini_rwc, Transcript::proof_data);
458 serialize_to_buffer<Commitment>(avmMini_mem_idx_a, Transcript::proof_data);
459 serialize_to_buffer<Commitment>(avmMini_mem_idx_b, Transcript::proof_data);
460 serialize_to_buffer<Commitment>(avmMini_mem_idx_c, Transcript::proof_data);
461 serialize_to_buffer<Commitment>(avmMini_last, Transcript::proof_data);
462
463 for (size_t i = 0; i < log_n; ++i) {
464 serialize_to_buffer(sumcheck_univariates[i], Transcript::proof_data);
465 }
466 serialize_to_buffer(sumcheck_evaluations, Transcript::proof_data);
467 for (size_t i = 0; i < log_n; ++i) {
468 serialize_to_buffer(zm_cq_comms[i], proof_data);
469 }
470 serialize_to_buffer(zm_cq_comm, proof_data);
471 serialize_to_buffer(zm_pi_comm, proof_data);
472
473 // sanity check to make sure we generate the same length of proof as before.
474 ASSERT(proof_data.size() == old_proof_length);
475 }
476 };
477};
478
479} // namespace flavor
480} // namespace proof_system::honk
RefVector
A template class for a reference vector. Behaves as if std::vector<T&> was possible.
Definition: ref_vector.hpp:20
barretenberg::Polynomial
Definition: polynomial.hpp:12
barretenberg::Univariate
A univariate polynomial represented by its values on {domain_start, domain_start + 1,...
Definition: univariate.hpp:23
curve::BN254
Definition: bn254.hpp:10
proof_system::Relation
The templates defined herein facilitate sharing the relation arithmetic between the prover and the ve...
Definition: relation_types.hpp:121
proof_system::honk::BaseTranscript
Common transcript class for both parties. Stores the data for the current round, as well as the manif...
Definition: transcript.hpp:62
proof_system::honk::BaseTranscript::deserialize_from_buffer
T deserialize_from_buffer(const Proof &proof_data, size_t &offset) const
Deserializes the bytes starting at offset into the typed element and returns that element.
Definition: transcript.hpp:180
proof_system::honk::BaseTranscript::serialize_to_buffer
void serialize_to_buffer(const T &element, Proof &proof_data)
Serializes object and appends it to proof_data.
Definition: transcript.hpp:166
proof_system::honk::flavor::AvmMiniFlavor::AllValues
Definition: AvmMini_flavor.hpp:254
proof_system::honk::flavor::AvmMiniFlavor::CommitmentLabels
Definition: AvmMini_flavor.hpp:311
proof_system::honk::flavor::AvmMiniFlavor::PartiallyEvaluatedMultivariates
Definition: AvmMini_flavor.hpp:288
proof_system::honk::flavor::AvmMiniFlavor::ProverPolynomials
A container for the prover polynomials handles.
Definition: AvmMini_flavor.hpp:263
proof_system::honk::flavor::AvmMiniFlavor::ProverPolynomials::get_row
AllValues get_row(size_t row_idx) const
Returns the evaluations of all prover polynomials at one point on the boolean hypercube,...
Definition: AvmMini_flavor.hpp:277
proof_system::honk::flavor::AvmMiniFlavor::ProvingKey
Definition: AvmMini_flavor.hpp:231
proof_system::honk::flavor::AvmMiniFlavor::Transcript
Definition: AvmMini_flavor.hpp:356
proof_system::honk::flavor::AvmMiniFlavor::VerifierCommitments
Definition: AvmMini_flavor.hpp:344
proof_system::honk::flavor::AvmMiniFlavor
Definition: AvmMini_flavor.hpp:21
proof_system::honk::flavor::AvmMiniFlavor::ExtendedEdges
ProverUnivariates< MAX_PARTIAL_RELATION_LENGTH > ExtendedEdges
A container for univariates produced during the hot loop in sumcheck.
Definition: AvmMini_flavor.hpp:309
proof_system::honk::flavor::AvmMiniFlavor::ProverUnivariates
AllEntities< barretenberg::Univariate< FF, LENGTH > > ProverUnivariates
A container for univariates used during Protogalaxy folding and sumcheck.
Definition: AvmMini_flavor.hpp:304
proof_system::honk::flavor::PrecomputedEntitiesBase
Base class template containing circuit-specifying data.
Definition: flavor.hpp:85
proof_system::honk::flavor::ProvingKey_
Base proving key class.
Definition: flavor.hpp:101
proof_system::honk::flavor::VerificationKey_< PrecomputedEntities< Commitment > >
proof_system::honk::pcs::CommitmentKey
CommitmentKey object over a pairing group 𝔾₁.
Definition: commitment_key.hpp:35
proof_system::honk::pcs::VerifierCommitmentKey
Definition: verification_key.hpp:25
proof_system::honk::pcs::kzg::KZG
Definition: kzg.hpp:14
zip_view
Definition: zip_view.hpp:159
flavor.hpp
Base class templates for structures that contain data parameterized by the fundamental polynomials of...
proof_system::honk
Defines particular circuit builder types expected to be used for circuit construction in stdlib and c...
Definition: claim.hpp:6
Generated by doxygen 1.9.6