1use alloc::vec::Vec;
2use core::mem::size_of;
3
4use crate::{
5 AbsoluteBits, AtomId, CertifiedF64, ConsumerId, EvalError, ExactValue, ExprId, InsertError,
6 ResolveError, StorageError,
7};
8use neco_algnum::IsolatingInterval;
9
10#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
11pub enum StorageResource {
12 GraphNodes,
13 AtomEntries,
14 PrecisionEntries,
15 AssignmentEntries,
16 EvaluationEntries,
17 IsolationEntries,
18 ResolvedEntries,
19 ProductEntries,
20 ProductResolutionEntries,
21}
22
23#[derive(Debug, Eq, PartialEq)]
24pub struct AtomStore {
25 entries: Vec<(AtomId, ExactValue)>,
26}
27
28#[derive(Debug, Eq, PartialEq)]
29pub struct PrecisionRequirements {
30 entries: Vec<(ConsumerId, AbsoluteBits)>,
31}
32
33#[derive(Debug, Eq, PartialEq)]
34pub struct Assignments {
35 entries: Vec<(ConsumerId, ExprId)>,
36}
37
38#[derive(Debug, Eq, PartialEq)]
39pub struct EvaluationCache {
40 entries: Vec<(ExprId, Result<ExactValue, EvalError>)>,
41}
42
43#[derive(Debug, Eq, PartialEq)]
44pub struct IsolationCache {
45 entries: Vec<((ExprId, AbsoluteBits), IsolatingInterval)>,
46}
47
48#[derive(Debug, Eq, PartialEq)]
49pub struct ResolvedValues {
50 entries: Vec<(ConsumerId, Result<CertifiedF64, ResolveError>)>,
51}
52
53#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
54impl AtomStore {
55 pub fn new() -> Self {
56 Self {
57 entries: Vec::new(),
58 }
59 }
60
61 pub fn len(&self) -> usize {
62 self.entries.len()
63 }
64
65 pub fn get(&self, id: AtomId) -> Option<&ExactValue> {
66 get_entry(&self.entries, id)
67 }
68
69 pub fn insert(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
70 insert_entry(
71 &mut self.entries,
72 id,
73 value,
74 StorageResource::AtomEntries,
75 id.get(),
76 )
77 }
78
79 pub fn set(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
80 set_entry(
81 &mut self.entries,
82 id,
83 value,
84 StorageResource::AtomEntries,
85 id.get(),
86 )
87 }
88
89 pub fn try_clone(&self) -> Result<Self, InsertError> {
90 let mut entries = Vec::new();
91 reserve_entries(
92 &mut entries,
93 self.entries.len(),
94 StorageResource::AtomEntries,
95 )?;
96 for (id, value) in &self.entries {
97 entries.push((*id, value.try_clone().map_err(atom_value_error)?));
98 }
99 Ok(Self { entries })
100 }
101}
102
103fn atom_value_error(error: EvalError) -> InsertError {
104 InsertError::Value(atom_value_payload(error))
105}
106
107fn atom_value_payload(error: EvalError) -> EvalError {
108 error
109}
110
111#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
112impl PrecisionRequirements {
113 pub fn new() -> Self {
114 Self {
115 entries: Vec::new(),
116 }
117 }
118
119 pub fn len(&self) -> usize {
120 self.entries.len()
121 }
122
123 pub fn get(&self, id: ConsumerId) -> Option<AbsoluteBits> {
124 get_entry(&self.entries, id).copied()
125 }
126
127 pub fn insert(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
128 insert_entry(
129 &mut self.entries,
130 id,
131 bits,
132 StorageResource::PrecisionEntries,
133 id.get(),
134 )
135 }
136
137 pub fn set(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
138 set_entry(
139 &mut self.entries,
140 id,
141 bits,
142 StorageResource::PrecisionEntries,
143 id.get(),
144 )
145 }
146
147 pub fn try_clone(&self) -> Result<Self, InsertError> {
148 Ok(Self {
149 entries: try_clone_copy_entries(&self.entries, StorageResource::PrecisionEntries)?,
150 })
151 }
152
153 pub(crate) fn entries(&self) -> &[(ConsumerId, AbsoluteBits)] {
154 &self.entries
155 }
156}
157
158#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
159impl Assignments {
160 pub fn new() -> Self {
161 Self {
162 entries: Vec::new(),
163 }
164 }
165
166 pub fn len(&self) -> usize {
167 self.entries.len()
168 }
169
170 pub fn get(&self, id: ConsumerId) -> Option<ExprId> {
171 get_entry(self.entries(), id).copied()
172 }
173
174 pub fn insert(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
175 insert_entry(
176 &mut self.entries,
177 id,
178 expr,
179 StorageResource::AssignmentEntries,
180 id.get(),
181 )
182 }
183
184 pub fn set(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
185 set_entry(
186 &mut self.entries,
187 id,
188 expr,
189 StorageResource::AssignmentEntries,
190 id.get(),
191 )
192 }
193
194 pub fn try_clone(&self) -> Result<Self, InsertError> {
195 Ok(Self {
196 entries: try_clone_copy_entries(&self.entries, StorageResource::AssignmentEntries)?,
197 })
198 }
199
200 pub(crate) fn entries(&self) -> &[(ConsumerId, ExprId)] {
201 &self.entries
202 }
203}
204
205#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
206impl EvaluationCache {
207 pub(crate) fn new() -> Self {
208 Self {
209 entries: Vec::new(),
210 }
211 }
212
213 pub fn len(&self) -> usize {
214 self.entries.len()
215 }
216
217 pub fn get(&self, id: ExprId) -> Option<&Result<ExactValue, EvalError>> {
218 get_entry(&self.entries, id)
219 }
220
221 pub(crate) fn get_mut(&mut self, id: ExprId) -> Option<&mut Result<ExactValue, EvalError>> {
222 self.entries
223 .binary_search_by(|(candidate, _)| candidate.cmp(&id))
224 .ok()
225 .map(|index| &mut self.entries[index].1)
226 }
227
228 pub(crate) fn insert(
229 &mut self,
230 id: ExprId,
231 value: Result<ExactValue, EvalError>,
232 ) -> Result<(), StorageError> {
233 let index = match find_key(&self.entries, &id) {
234 Ok(_) => return Ok(()),
235 Err(index) => index,
236 };
237 let required = required_elements(self.entries.len(), StorageResource::EvaluationEntries)?;
238 reserve_entries(
239 &mut self.entries,
240 required,
241 StorageResource::EvaluationEntries,
242 )?;
243 self.entries.insert(index, (id, value));
244 Ok(())
245 }
246}
247
248#[allow(clippy::len_without_is_empty)]
249impl IsolationCache {
250 pub(crate) fn new() -> Self {
251 Self {
252 entries: Vec::new(),
253 }
254 }
255
256 pub fn len(&self) -> usize {
257 self.entries.len()
258 }
259
260 pub fn get(&self, id: ExprId, bits: AbsoluteBits) -> Option<&IsolatingInterval> {
261 get_entry(&self.entries, (id, bits))
262 }
263
264 pub(crate) fn insert(
265 &mut self,
266 id: ExprId,
267 bits: AbsoluteBits,
268 interval: IsolatingInterval,
269 ) -> Result<(), StorageError> {
270 insert_cache_entry(
271 &mut self.entries,
272 (id, bits),
273 interval,
274 StorageResource::IsolationEntries,
275 )
276 }
277}
278
279#[allow(clippy::len_without_is_empty)]
280impl ResolvedValues {
281 pub(crate) fn new() -> Self {
282 Self {
283 entries: Vec::new(),
284 }
285 }
286
287 pub fn len(&self) -> usize {
288 self.entries.len()
289 }
290
291 pub fn get(&self, id: ConsumerId) -> Option<&Result<CertifiedF64, ResolveError>> {
292 get_entry(&self.entries, id)
293 }
294
295 pub(crate) fn insert(
296 &mut self,
297 id: ConsumerId,
298 value: Result<CertifiedF64, ResolveError>,
299 ) -> Result<(), StorageError> {
300 insert_cache_entry(
301 &mut self.entries,
302 id,
303 value,
304 StorageResource::ResolvedEntries,
305 )
306 }
307}
308
309fn insert_cache_entry<K: Ord, V>(
310 entries: &mut Vec<(K, V)>,
311 key: K,
312 value: V,
313 resource: StorageResource,
314) -> Result<(), StorageError> {
315 let index = match find_key(entries, &key) {
316 Ok(_) => return Ok(()),
317 Err(index) => index,
318 };
319 let required = required_elements(entries.len(), resource)?;
320 reserve_entries(entries, required, resource)?;
321 entries.insert(index, (key, value));
322 Ok(())
323}
324
325fn find_key<K: Ord, V>(entries: &[(K, V)], key: &K) -> Result<usize, usize> {
326 entries.binary_search_by(|(candidate, _)| candidate.cmp(key))
327}
328
329fn get_entry<K: Ord, V>(entries: &[(K, V)], key: K) -> Option<&V> {
330 find_key(entries, &key).ok().map(|index| &entries[index].1)
331}
332
333fn insert_entry<K: Ord, V>(
334 entries: &mut Vec<(K, V)>,
335 key: K,
336 value: V,
337 resource: StorageResource,
338 id: u32,
339) -> Result<(), InsertError> {
340 let index = match find_key(entries, &key) {
341 Ok(_) => return Err(InsertError::DuplicateId { resource, id }),
342 Err(index) => index,
343 };
344 let required = required_elements(entries.len(), resource)?;
345 reserve_entries(entries, required, resource)?;
346 entries.insert(index, (key, value));
347 Ok(())
348}
349
350fn set_entry<K: Ord, V>(
351 entries: &mut Vec<(K, V)>,
352 key: K,
353 value: V,
354 resource: StorageResource,
355 id: u32,
356) -> Result<(), InsertError> {
357 match find_key(entries, &key) {
358 Ok(index) => {
359 entries[index].1 = value;
360 Ok(())
361 }
362 Err(_) => insert_entry(entries, key, value, resource, id),
363 }
364}
365
366fn try_clone_copy_entries<K: Copy, V: Copy>(
367 source: &[(K, V)],
368 resource: StorageResource,
369) -> Result<Vec<(K, V)>, InsertError> {
370 let mut entries = Vec::new();
371 reserve_entries(&mut entries, source.len(), resource)?;
372 entries.extend_from_slice(source);
373 Ok(entries)
374}
375
376pub(crate) fn required_elements(
377 current: usize,
378 resource: StorageResource,
379) -> Result<usize, StorageError> {
380 current
381 .checked_add(1)
382 .ok_or(StorageError::CapacityOverflow { resource })
383}
384
385pub(crate) fn reserve_entries<T>(
386 entries: &mut Vec<T>,
387 total_required: usize,
388 resource: StorageResource,
389) -> Result<(), StorageError> {
390 #[cfg(test)]
391 if let Some(error) = injected_failure(resource, total_required) {
392 return Err(error);
393 }
394
395 let maximum = if size_of::<T>() == 0 {
396 usize::MAX
397 } else {
398 (isize::MAX as usize) / size_of::<T>()
399 };
400 if total_required > maximum {
401 return Err(StorageError::CapacityOverflow { resource });
402 }
403 let additional = total_required
404 .checked_sub(entries.len())
405 .ok_or(StorageError::CapacityOverflow { resource })?;
406 entries
407 .try_reserve(additional)
408 .map_err(|_| StorageError::AllocationFailure {
409 resource,
410 requested_elements: total_required,
411 })
412}
413
414#[cfg(test)]
415#[derive(Clone, Copy)]
416pub(crate) enum InjectedFailure {
417 Capacity,
418 Allocation,
419}
420
421#[cfg(test)]
422std::thread_local! {
423 static INJECTED_FAILURE: core::cell::Cell<Option<(StorageResource, InjectedFailure)>> = const { core::cell::Cell::new(None) };
424}
425
426#[cfg(test)]
427fn injected_failure(resource: StorageResource, requested_elements: usize) -> Option<StorageError> {
428 INJECTED_FAILURE.with(|configured| {
429 let error = match configured.get() {
430 Some((expected, InjectedFailure::Capacity)) if expected == resource => {
431 Some(StorageError::CapacityOverflow { resource })
432 }
433 Some((expected, InjectedFailure::Allocation)) if expected == resource => {
434 Some(StorageError::AllocationFailure {
435 resource,
436 requested_elements,
437 })
438 }
439 _ => None,
440 };
441 if error.is_some() {
442 configured.set(None);
443 }
444 error
445 })
446}
447
448#[cfg(test)]
449pub(crate) fn with_injected_failure<R>(
450 resource: StorageResource,
451 failure: InjectedFailure,
452 operation: impl FnOnce() -> R,
453) -> R {
454 INJECTED_FAILURE.with(|configured| configured.set(Some((resource, failure))));
455 let result = operation();
456 INJECTED_FAILURE.with(|configured| configured.set(None));
457 result
458}
459
460#[cfg(test)]
461mod tests {
462 use alloc::vec;
463 use alloc::vec::Vec;
464
465 use neco_algnum::RealAlgebraic;
466 use neco_formsum::FormSum;
467 use neco_monomial::{Monomial, MonomialErrorKind};
468
469 use super::{
470 required_elements, reserve_entries, with_injected_failure, InjectedFailure, StorageResource,
471 };
472 use crate::value::{with_clone_failure, CloneContact};
473 use crate::{
474 AbsoluteBits, Assignments, AtomId, AtomStore, ConsumerId, EvalError, ExactValue, ExprGraph,
475 ExprNode, GraphError, InsertError, PrecisionRequirements, ResolveError, Resolver,
476 StorageError,
477 };
478
479 const RESOURCES: [StorageResource; 7] = [
480 StorageResource::GraphNodes,
481 StorageResource::AtomEntries,
482 StorageResource::PrecisionEntries,
483 StorageResource::AssignmentEntries,
484 StorageResource::EvaluationEntries,
485 StorageResource::IsolationEntries,
486 StorageResource::ResolvedEntries,
487 ];
488
489 #[test]
490 fn required_total_rejects_capacity_overflow() {
491 for resource in RESOURCES {
492 assert_eq!(
493 required_elements(usize::MAX, resource),
494 Err(StorageError::CapacityOverflow { resource })
495 );
496 }
497 }
498
499 #[test]
500 fn allocation_failure_reports_total_and_preserves_entries() {
501 let mut entries = vec![10_u32];
502 let result = with_injected_failure(
503 StorageResource::PrecisionEntries,
504 InjectedFailure::Allocation,
505 || reserve_entries(&mut entries, 2, StorageResource::PrecisionEntries),
506 );
507 assert_eq!(
508 result,
509 Err(StorageError::AllocationFailure {
510 resource: StorageResource::PrecisionEntries,
511 requested_elements: 2,
512 })
513 );
514 assert_eq!(entries, [10]);
515 }
516
517 #[test]
518 fn capacity_injection_uses_production_reservation_path() {
519 let mut requirements = PrecisionRequirements::new();
520 let result = with_injected_failure(
521 StorageResource::PrecisionEntries,
522 InjectedFailure::Capacity,
523 || requirements.insert(ConsumerId::new(1), AbsoluteBits::new(20)),
524 );
525 assert_eq!(
526 result,
527 Err(InsertError::Storage(StorageError::CapacityOverflow {
528 resource: StorageResource::PrecisionEntries,
529 }))
530 );
531 assert_eq!(requirements.len(), 0);
532 }
533
534 #[test]
535 fn allocation_injection_identifies_every_resource() {
536 for resource in RESOURCES {
537 let mut entries = Vec::<u32>::new();
538 let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
539 reserve_entries(&mut entries, 1, resource)
540 });
541 assert_eq!(
542 result,
543 Err(StorageError::AllocationFailure {
544 resource,
545 requested_elements: 1,
546 })
547 );
548 assert!(entries.is_empty());
549 }
550 }
551
552 #[test]
553 fn map_order_duplicate_and_set_are_deterministic() {
554 let mut left = PrecisionRequirements::new();
555 left.insert(ConsumerId::new(2), AbsoluteBits::new(20))
556 .unwrap();
557 left.insert(ConsumerId::new(1), AbsoluteBits::new(10))
558 .unwrap();
559
560 let mut right = PrecisionRequirements::new();
561 right
562 .insert(ConsumerId::new(1), AbsoluteBits::new(10))
563 .unwrap();
564 right
565 .insert(ConsumerId::new(2), AbsoluteBits::new(20))
566 .unwrap();
567 assert_eq!(left, right);
568
569 assert_eq!(
570 left.insert(ConsumerId::new(1), AbsoluteBits::new(99)),
571 Err(InsertError::DuplicateId {
572 resource: StorageResource::PrecisionEntries,
573 id: 1,
574 })
575 );
576 assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(10)));
577
578 left.set(ConsumerId::new(1), AbsoluteBits::new(30)).unwrap();
579 assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(30)));
580 assert_eq!(left.len(), 2);
581 }
582
583 #[test]
584 fn graph_storage_failure_is_wrapped_and_preserves_graph() {
585 let mut graph = ExprGraph::new();
586 let result = with_injected_failure(
587 StorageResource::GraphNodes,
588 InjectedFailure::Allocation,
589 || graph.push(ExprNode::Atom(AtomId::new(0))),
590 );
591 assert_eq!(
592 result,
593 Err(GraphError::Storage(StorageError::AllocationFailure {
594 resource: StorageResource::GraphNodes,
595 requested_elements: 1,
596 }))
597 );
598 assert!(graph.is_empty());
599 }
600
601 #[test]
602 fn every_input_map_wraps_allocation_failure_and_preserves_its_value() {
603 let mut atoms = AtomStore::new();
604 let atom_result = with_injected_failure(
605 StorageResource::AtomEntries,
606 InjectedFailure::Allocation,
607 || atoms.insert(AtomId::new(4), ExactValue::Monomial(Monomial::one())),
608 );
609 assert_eq!(
610 atom_result,
611 Err(InsertError::Storage(StorageError::AllocationFailure {
612 resource: StorageResource::AtomEntries,
613 requested_elements: 1,
614 }))
615 );
616 assert_eq!(atoms.len(), 0);
617
618 let mut requirements = PrecisionRequirements::new();
619 let precision_result = with_injected_failure(
620 StorageResource::PrecisionEntries,
621 InjectedFailure::Allocation,
622 || requirements.insert(ConsumerId::new(4), AbsoluteBits::new(20)),
623 );
624 assert_eq!(
625 precision_result,
626 Err(InsertError::Storage(StorageError::AllocationFailure {
627 resource: StorageResource::PrecisionEntries,
628 requested_elements: 1,
629 }))
630 );
631 assert_eq!(requirements.len(), 0);
632
633 let mut assignments = Assignments::new();
634 let assignment_result = with_injected_failure(
635 StorageResource::AssignmentEntries,
636 InjectedFailure::Allocation,
637 || assignments.insert(ConsumerId::new(4), crate::ExprId::new(0)),
638 );
639 assert_eq!(
640 assignment_result,
641 Err(InsertError::Storage(StorageError::AllocationFailure {
642 resource: StorageResource::AssignmentEntries,
643 requested_elements: 1,
644 }))
645 );
646 assert_eq!(assignments.len(), 0);
647 }
648
649 #[test]
650 fn atom_clone_failure_is_value_error_with_the_original_payload() {
651 let mut atoms = AtomStore::new();
652 atoms
653 .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
654 .unwrap();
655 assert_eq!(
656 with_clone_failure(CloneContact::Monomial, || atoms.try_clone()),
657 Err(InsertError::Value(EvalError::Monomial(
658 MonomialErrorKind::AllocationFailure {
659 requested_elements: 19,
660 }
661 )))
662 );
663 assert_eq!(atoms.len(), 1);
664 }
665
666 #[test]
667 fn evaluation_clone_failure_is_local_and_preserves_the_cache_entry() {
668 let mut graph = ExprGraph::new();
669 let failed = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
670 let succeeded = graph.push(ExprNode::Atom(AtomId::new(1))).unwrap();
671 let mut atoms = AtomStore::new();
672 atoms
673 .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
674 .unwrap();
675 atoms
676 .insert(AtomId::new(1), ExactValue::FormSum(FormSum::one().unwrap()))
677 .unwrap();
678 let mut requirements = PrecisionRequirements::new();
679 let mut assignments = Assignments::new();
680 for (consumer, expression) in [
681 (ConsumerId::new(0), failed),
682 (ConsumerId::new(1), succeeded),
683 ] {
684 requirements.insert(consumer, AbsoluteBits::new(0)).unwrap();
685 assignments.insert(consumer, expression).unwrap();
686 }
687 let (evaluation, _, resolved) = with_clone_failure(CloneContact::Monomial, || {
688 Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
689 })
690 .unwrap();
691 let expected = EvalError::Monomial(MonomialErrorKind::AllocationFailure {
692 requested_elements: 19,
693 });
694 assert_eq!(evaluation.get(failed), Some(&Err(expected)));
695 assert_eq!(
696 resolved.get(ConsumerId::new(0)),
697 Some(&Err(ResolveError::Evaluation(EvalError::Monomial(
698 MonomialErrorKind::AllocationFailure {
699 requested_elements: 19,
700 }
701 ))))
702 );
703 assert!(resolved.get(ConsumerId::new(1)).unwrap().as_ref().is_ok());
704 }
705
706 #[test]
707 fn resolver_reports_evaluation_and_result_storage_failures_globally() {
708 let mut graph = ExprGraph::new();
709 let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
710 let mut atoms = AtomStore::new();
711 atoms
712 .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
713 .unwrap();
714 let mut requirements = PrecisionRequirements::new();
715 requirements
716 .insert(ConsumerId::new(0), AbsoluteBits::new(0))
717 .unwrap();
718 let mut assignments = Assignments::new();
719 assignments.insert(ConsumerId::new(0), expr).unwrap();
720
721 for resource in [
722 StorageResource::EvaluationEntries,
723 StorageResource::ResolvedEntries,
724 ] {
725 let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
726 Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
727 });
728 assert_eq!(
729 result,
730 Err(ResolveError::Storage(StorageError::AllocationFailure {
731 resource,
732 requested_elements: 1,
733 }))
734 );
735 }
736 }
737
738 #[test]
739 fn resolver_reports_isolation_storage_failure_globally() {
740 let form = FormSum::one().unwrap();
741 let mut graph = ExprGraph::new();
742 let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
743 let mut atoms = AtomStore::new();
744 atoms
745 .insert(
746 AtomId::new(0),
747 ExactValue::Algebraic(RealAlgebraic::from_form_sum(&form).unwrap()),
748 )
749 .unwrap();
750 let mut requirements = PrecisionRequirements::new();
751 requirements
752 .insert(ConsumerId::new(0), AbsoluteBits::new(0))
753 .unwrap();
754 let mut assignments = Assignments::new();
755 assignments.insert(ConsumerId::new(0), expr).unwrap();
756
757 let result = with_injected_failure(
758 StorageResource::IsolationEntries,
759 InjectedFailure::Allocation,
760 || Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments),
761 );
762 assert_eq!(
763 result,
764 Err(ResolveError::Storage(StorageError::AllocationFailure {
765 resource: StorageResource::IsolationEntries,
766 requested_elements: 1,
767 }))
768 );
769 }
770}