diff --git a/contracts/feature-tests/basic-features/scenarios/managed_vec_array_push.scen.json b/contracts/feature-tests/basic-features/scenarios/managed_vec_array_push.scen.json deleted file mode 100644 index 1412fd5e31..0000000000 --- a/contracts/feature-tests/basic-features/scenarios/managed_vec_array_push.scen.json +++ /dev/null @@ -1,52 +0,0 @@ -{ - "steps": [ - { - "step": "setState", - "accounts": { - "sc:basic-features": { - "nonce": "0", - "balance": "0", - "code": "mxsc:../output/basic-features.mxsc.json" - }, - "address:an_account": { - "nonce": "0", - "balance": "0" - } - } - }, - { - "step": "scQuery", - "id": "1", - "tx": { - "to": "sc:basic-features", - "function": "managed_vec_array_push", - "arguments": [ - "", - "str:12345" - ] - }, - "expect": { - "out": [ - "str:12345" - ] - } - }, - { - "step": "scQuery", - "id": "1", - "tx": { - "to": "sc:basic-features", - "function": "managed_vec_array_push", - "arguments": [ - "str:12345", - "str:67890" - ] - }, - "expect": { - "out": [ - "str:1234567890" - ] - } - } - ] -} diff --git a/contracts/feature-tests/basic-features/src/managed_vec_features.rs b/contracts/feature-tests/basic-features/src/managed_vec_features.rs index 63aaab5811..6f42d104be 100644 --- a/contracts/feature-tests/basic-features/src/managed_vec_features.rs +++ b/contracts/feature-tests/basic-features/src/managed_vec_features.rs @@ -67,16 +67,6 @@ pub trait ManagedVecFeatures { mv.contains(&item) } - #[endpoint] - fn managed_vec_array_push( - &self, - mut mv: ManagedVec<[u8; 5]>, - item: [u8; 5], - ) -> ManagedVec<[u8; 5]> { - mv.push(item); - mv - } - #[endpoint] fn managed_ref_explicit(&self, mv: ManagedVec, index: usize) -> BigUint { let value: ManagedRef = mv.get(index); diff --git a/contracts/feature-tests/basic-features/tests/basic_features_scenario_go_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_scenario_go_test.rs index 3c75401525..6ef518cf9f 100644 --- a/contracts/feature-tests/basic-features/tests/basic_features_scenario_go_test.rs +++ b/contracts/feature-tests/basic-features/tests/basic_features_scenario_go_test.rs @@ -255,11 +255,6 @@ fn managed_vec_address_push_go() { world().run("scenarios/managed_vec_address_push.scen.json"); } -#[test] -fn managed_vec_array_push_go() { - world().run("scenarios/managed_vec_array_push.scen.json"); -} - #[test] fn managed_vec_biguint_push_go() { world().run("scenarios/managed_vec_biguint_push.scen.json"); diff --git a/contracts/feature-tests/basic-features/tests/basic_features_scenario_rs_test.rs b/contracts/feature-tests/basic-features/tests/basic_features_scenario_rs_test.rs index 0129da845e..a799f9218a 100644 --- a/contracts/feature-tests/basic-features/tests/basic_features_scenario_rs_test.rs +++ b/contracts/feature-tests/basic-features/tests/basic_features_scenario_rs_test.rs @@ -271,11 +271,6 @@ fn managed_vec_address_push_rs() { world().run("scenarios/managed_vec_address_push.scen.json"); } -#[test] -fn managed_vec_array_push_rs() { - world().run("scenarios/managed_vec_array_push.scen.json"); -} - #[test] fn managed_vec_biguint_push_rs() { world().run("scenarios/managed_vec_biguint_push.scen.json"); diff --git a/framework/base/src/lib.rs b/framework/base/src/lib.rs index 2b9f8669f7..8214ecb4bd 100644 --- a/framework/base/src/lib.rs +++ b/framework/base/src/lib.rs @@ -1,6 +1,5 @@ #![no_std] -#![feature(generic_const_exprs)] -#![allow(incomplete_features)] + #![allow(deprecated)] pub use multiversx_sc_derive::{self as derive, contract, module, proxy}; diff --git a/framework/base/src/types/flags/esdt_local_role.rs b/framework/base/src/types/flags/esdt_local_role.rs index 9bc5edfc68..b66ac612f5 100644 --- a/framework/base/src/types/flags/esdt_local_role.rs +++ b/framework/base/src/types/flags/esdt_local_role.rs @@ -1,11 +1,13 @@ -use crate::{ - codec, - codec::derive::{NestedDecode, NestedEncode, TopDecode, TopEncode}, -}; - use super::EsdtLocalRoleFlags; use crate as multiversx_sc; -use crate::{derive::type_abi, types::ManagedVecItem}; +use crate::{ + codec::{ + self, + derive::{NestedDecode, NestedEncode, TopDecode, TopEncode}, + }, + derive::type_abi, + types::{ManagedVecItem, ManagedVecItemPayloadBuffer}, +}; static ESDT_ROLE_NONE: &[u8] = &[]; static ESDT_ROLE_LOCAL_MINT: &[u8] = b"ESDTRoleLocalMint"; @@ -137,7 +139,7 @@ impl<'a> From<&'a [u8]> for EsdtLocalRole { } impl ManagedVecItem for EsdtLocalRole { - const PAYLOAD_SIZE: usize = 1; + type PAYLOAD = ManagedVecItemPayloadBuffer<1>; const SKIPS_RESERIALIZATION: bool = false; // TODO: might be ok to be true, but needs testing type Ref<'a> = Self; diff --git a/framework/base/src/types/managed/multi_value/esdt_token_payment_multi_value.rs b/framework/base/src/types/managed/multi_value/esdt_token_payment_multi_value.rs index d9b312f45b..7e7cd934a3 100644 --- a/framework/base/src/types/managed/multi_value/esdt_token_payment_multi_value.rs +++ b/framework/base/src/types/managed/multi_value/esdt_token_payment_multi_value.rs @@ -40,7 +40,7 @@ impl EsdtTokenPaymentMultiValue { } impl ManagedVecItem for EsdtTokenPaymentMultiValue { - const PAYLOAD_SIZE: usize = EsdtTokenPayment::::PAYLOAD_SIZE; + type PAYLOAD = as ManagedVecItem>::PAYLOAD; const SKIPS_RESERIALIZATION: bool = EsdtTokenPayment::::SKIPS_RESERIALIZATION; type Ref<'a> = Self; diff --git a/framework/base/src/types/managed/wrapped/encoded_managed_vec_item.rs b/framework/base/src/types/managed/wrapped/encoded_managed_vec_item.rs index 12a0e3defc..fd7af7c51f 100644 --- a/framework/base/src/types/managed/wrapped/encoded_managed_vec_item.rs +++ b/framework/base/src/types/managed/wrapped/encoded_managed_vec_item.rs @@ -1,23 +1,21 @@ -use super::ManagedVecItem; +use super::{ManagedVecItem, ManagedVecItemPayload}; use core::{cmp::Ordering, marker::PhantomData}; pub struct EncodedManagedVecItem where T: ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, { - pub encoded: [u8; ::PAYLOAD_SIZE], + pub encoded: T::PAYLOAD, _phantom: PhantomData, } impl EncodedManagedVecItem where T: ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, { pub(crate) fn decode(&self) -> T { T::from_byte_reader(|item_bytes| { - item_bytes.copy_from_slice(&self.encoded); + item_bytes.copy_from_slice(self.encoded.payload_slice()); }) } } @@ -25,7 +23,6 @@ where impl PartialEq for EncodedManagedVecItem where T: PartialEq + ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, { #[inline] fn eq(&self, other: &Self) -> bool { @@ -33,17 +30,11 @@ where } } -impl Eq for EncodedManagedVecItem -where - T: Eq + ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, -{ -} +impl Eq for EncodedManagedVecItem where T: Eq + ManagedVecItem {} impl PartialOrd for EncodedManagedVecItem where T: PartialOrd + ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, { #[inline] fn partial_cmp(&self, other: &Self) -> Option { @@ -54,7 +45,6 @@ where impl Ord for EncodedManagedVecItem where T: Ord + ManagedVecItem, - [(); ::PAYLOAD_SIZE]:, { fn cmp(&self, other: &Self) -> Ordering { self.decode().cmp(&other.decode()) diff --git a/framework/base/src/types/managed/wrapped/esdt_token_payment.rs b/framework/base/src/types/managed/wrapped/esdt_token_payment.rs index ac7a54c442..32862726ed 100644 --- a/framework/base/src/types/managed/wrapped/esdt_token_payment.rs +++ b/framework/base/src/types/managed/wrapped/esdt_token_payment.rs @@ -13,7 +13,7 @@ use crate::{ derive::type_abi, }; -use super::ManagedVec; +use super::{ManagedVec, ManagedVecItemPayloadBuffer}; #[type_abi] #[derive(TopEncode, NestedEncode, Clone, PartialEq, Eq, Debug)] @@ -158,7 +158,7 @@ where T: ManagedVecItem, { ManagedVecItem::from_byte_reader(|bytes| { - let size = T::PAYLOAD_SIZE; + let size = T::payload_size(); bytes.copy_from_slice(&arr[*index..*index + size]); *index += size; }) @@ -169,7 +169,7 @@ where T: ManagedVecItem, { ManagedVecItem::to_byte_writer(item, |bytes| { - let size = T::PAYLOAD_SIZE; + let size = T::payload_size(); arr[*index..*index + size].copy_from_slice(bytes); *index += size; }); @@ -185,7 +185,7 @@ impl IntoMultiValue for EsdtTokenPayment { } impl ManagedVecItem for EsdtTokenPayment { - const PAYLOAD_SIZE: usize = 16; + type PAYLOAD = ManagedVecItemPayloadBuffer<16>; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = Self; diff --git a/framework/base/src/types/managed/wrapped/managed_option.rs b/framework/base/src/types/managed/wrapped/managed_option.rs index a34a4f7ab3..ddedbbdb8d 100644 --- a/framework/base/src/types/managed/wrapped/managed_option.rs +++ b/framework/base/src/types/managed/wrapped/managed_option.rs @@ -14,7 +14,7 @@ use crate::{ types::{ManagedRef, ManagedType}, }; -use super::ManagedVecItem; +use super::{ManagedVecItem, ManagedVecItemPayloadBuffer}; /// A very efficient optional managed type. /// @@ -195,7 +195,7 @@ where M: ManagedTypeApi, T: ManagedType + 'static, { - const PAYLOAD_SIZE: usize = 4; + type PAYLOAD = ManagedVecItemPayloadBuffer<4>; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = Self; diff --git a/framework/base/src/types/managed/wrapped/managed_vec.rs b/framework/base/src/types/managed/wrapped/managed_vec.rs index 8ba9b1d355..e37dd872d5 100644 --- a/framework/base/src/types/managed/wrapped/managed_vec.rs +++ b/framework/base/src/types/managed/wrapped/managed_vec.rs @@ -123,7 +123,7 @@ where /// Number of items. #[inline] pub fn len(&self) -> usize { - self.byte_len() / T::PAYLOAD_SIZE + self.byte_len() / T::payload_size() } #[inline] @@ -132,7 +132,7 @@ where } pub fn try_get(&self, index: usize) -> Option> { - let byte_index = index * T::PAYLOAD_SIZE; + let byte_index = index * T::payload_size(); let mut load_result = Ok(()); let result = unsafe { T::from_byte_reader_as_borrow(|dest_slice| { @@ -178,7 +178,7 @@ where } pub(super) unsafe fn get_unsafe(&self, index: usize) -> T { - let byte_index = index * T::PAYLOAD_SIZE; + let byte_index = index * T::payload_size(); let mut load_result = Ok(()); let result = T::from_byte_reader(|dest_slice| { load_result = self.buffer.load_slice(byte_index, dest_slice); @@ -191,15 +191,15 @@ where } pub fn set(&mut self, index: usize, item: &T) -> Result<(), InvalidSliceError> { - let byte_index = index * T::PAYLOAD_SIZE; + let byte_index = index * T::payload_size(); item.to_byte_writer(|slice| self.buffer.set_slice(byte_index, slice)) } /// Returns a new `ManagedVec`, containing the [start_index, end_index) range of elements. /// Returns `None` if any index is out of range pub fn slice(&self, start_index: usize, end_index: usize) -> Option { - let byte_start = start_index * T::PAYLOAD_SIZE; - let byte_end = end_index * T::PAYLOAD_SIZE; + let byte_start = start_index * T::payload_size(); + let byte_end = end_index * T::payload_size(); let opt_buffer = self.buffer.copy_slice(byte_start, byte_end - byte_start); opt_buffer.map(ManagedVec::new_from_raw_buffer) } @@ -314,10 +314,9 @@ where fn with_self_as_slice(&self, f: F) -> R where F: FnOnce(&[EncodedManagedVecItem]) -> R, - [(); T::PAYLOAD_SIZE]:, { self.buffer.with_buffer_contents(|bytes| { - let item_len = bytes.len() / T::PAYLOAD_SIZE; + let item_len = bytes.len() / T::payload_size(); let values = Self::transmute_slice(bytes, item_len); f(values) }) @@ -326,14 +325,13 @@ where fn with_self_as_slice_mut(&mut self, f: F) where F: FnOnce(&mut [EncodedManagedVecItem]) -> &[EncodedManagedVecItem], - [(); T::PAYLOAD_SIZE]:, { self.buffer.with_buffer_contents_mut(|bytes| { - let item_len = bytes.len() / T::PAYLOAD_SIZE; + let item_len = bytes.len() / T::payload_size(); let values = Self::transmute_slice_mut(bytes, item_len); let result = f(values); - let result_len = result.len() * T::PAYLOAD_SIZE; + let result_len = result.len() * T::payload_size(); Self::transmute_slice(result, result_len) }); } @@ -357,7 +355,6 @@ impl ManagedVec where M: ManagedTypeApi, T: ManagedVecItem + Ord + Debug, - [(); T::PAYLOAD_SIZE]:, { pub fn sort(&mut self) { self.with_self_as_slice_mut(|slice| { @@ -398,10 +395,7 @@ where }); } - pub fn sort_unstable(&mut self) - where - [(); T::PAYLOAD_SIZE]:, - { + pub fn sort_unstable(&mut self) { self.with_self_as_slice_mut(|slice| { slice.sort_unstable(); slice @@ -411,7 +405,6 @@ where pub fn sort_unstable_by(&mut self, mut compare: F) where F: FnMut(&T, &T) -> Ordering, - [(); T::PAYLOAD_SIZE]:, { self.with_self_as_slice_mut(|slice| { slice.sort_unstable_by(|a, b| compare(&a.decode(), &b.decode())); @@ -423,7 +416,6 @@ where where F: FnMut(&T) -> K, K: Ord, - [(); T::PAYLOAD_SIZE]:, { self.with_self_as_slice_mut(|slice| { slice.sort_unstable_by_key(|a| f(&a.decode())); @@ -463,10 +455,7 @@ where M: ManagedTypeApi, T: ManagedVecItem + PartialEq + Debug, { - pub fn dedup(&mut self) - where - [(); T::PAYLOAD_SIZE]:, - { + pub fn dedup(&mut self) { self.with_self_as_slice_mut(|slice| { let same_bucket = |a, b| a == b; let len = slice.len(); @@ -539,7 +528,7 @@ where if self_item != other_item { return false; } - byte_index += T::PAYLOAD_SIZE; + byte_index += T::payload_size(); } true } diff --git a/framework/base/src/types/managed/wrapped/managed_vec_item.rs b/framework/base/src/types/managed/wrapped/managed_vec_item.rs index 100a85ec14..648635e143 100644 --- a/framework/base/src/types/managed/wrapped/managed_vec_item.rs +++ b/framework/base/src/types/managed/wrapped/managed_vec_item.rs @@ -1,4 +1,4 @@ -use core::{borrow::Borrow, mem::MaybeUninit}; +use core::borrow::Borrow; use crate::{ api::ManagedTypeApi, @@ -8,14 +8,16 @@ use crate::{ }, }; +use super::{ManagedVecItemNestedTuple, ManagedVecItemPayload, ManagedVecItemPayloadBuffer}; + /// Types that implement this trait can be items inside a `ManagedVec`. /// All these types need a payload, i.e a representation that gets stored /// in the underlying managed buffer. /// Not all data needs to be stored as payload, for instance for most managed types /// the payload is just the handle, whereas the mai ndata is kept by the VM. pub trait ManagedVecItem: 'static { - /// Size of the data stored in the underlying `ManagedBuffer`. - const PAYLOAD_SIZE: usize; + /// Type managing the underlying binary representation in a ManagedVec.. + type PAYLOAD: ManagedVecItemPayload; /// If true, then the encoding of the item is identical to the payload, /// and no further conversion is necessary @@ -32,6 +34,10 @@ pub trait ManagedVecItem: 'static { /// TODO: wrap other types in readonly wrapper. type Ref<'a>: Borrow; + fn payload_size() -> usize { + Self::PAYLOAD::payload_size() + } + /// Parses given bytes as a an owned object. fn from_byte_reader(reader: Reader) -> Self; @@ -50,7 +56,7 @@ pub trait ManagedVecItem: 'static { macro_rules! impl_int { ($ty:ident, $payload_size:expr) => { impl ManagedVecItem for $ty { - const PAYLOAD_SIZE: usize = $payload_size; + type PAYLOAD = ManagedVecItemPayloadBuffer<$payload_size>; const SKIPS_RESERIALIZATION: bool = true; type Ref<'a> = Self; fn from_byte_reader(mut reader: Reader) -> Self { @@ -79,7 +85,7 @@ impl_int! {i32, 4} impl_int! {i64, 8} impl ManagedVecItem for usize { - const PAYLOAD_SIZE: usize = 4; + type PAYLOAD = ManagedVecItemPayloadBuffer<4>; const SKIPS_RESERIALIZATION: bool = true; type Ref<'a> = Self; @@ -102,7 +108,7 @@ impl ManagedVecItem for usize { } impl ManagedVecItem for bool { - const PAYLOAD_SIZE: usize = 1; + type PAYLOAD = ManagedVecItemPayloadBuffer<1>; const SKIPS_RESERIALIZATION: bool = true; type Ref<'a> = Self; @@ -126,21 +132,22 @@ impl ManagedVecItem for bool { impl ManagedVecItem for Option where - [(); 1 + T::PAYLOAD_SIZE]:, + (u8, (T, ())): ManagedVecItemNestedTuple, T: ManagedVecItem, { - const PAYLOAD_SIZE: usize = 1 + T::PAYLOAD_SIZE; + type PAYLOAD = <(u8, (T, ())) as ManagedVecItemNestedTuple>::PAYLOAD; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = Self; fn from_byte_reader(mut reader: Reader) -> Self { - let mut byte_arr: [u8; 1 + T::PAYLOAD_SIZE] = [0u8; 1 + T::PAYLOAD_SIZE]; - reader(&mut byte_arr[..]); - if byte_arr[0] == 0 { + let mut payload = Self::PAYLOAD::new_buffer(); + let payload_slice = payload.payload_slice_mut(); + reader(payload_slice); + if payload_slice[0] == 0 { None } else { Some(T::from_byte_reader(|bytes| { - bytes.copy_from_slice(&byte_arr[1..]); + bytes.copy_from_slice(&payload_slice[1..]); })) } } @@ -152,21 +159,22 @@ where } fn to_byte_writer R>(&self, mut writer: Writer) -> R { - let mut byte_arr: [u8; 1 + T::PAYLOAD_SIZE] = [0u8; 1 + T::PAYLOAD_SIZE]; + let mut payload = Self::PAYLOAD::new_buffer(); + let slice = payload.payload_slice_mut(); if let Some(t) = self { - byte_arr[0] = 1; + slice[0] = 1; T::to_byte_writer(t, |bytes| { - byte_arr[1..].copy_from_slice(bytes); + slice[1..].copy_from_slice(bytes); }); } - writer(&byte_arr[..]) + writer(slice) } } macro_rules! impl_managed_type { ($ty:ident) => { impl ManagedVecItem for $ty { - const PAYLOAD_SIZE: usize = 4; + type PAYLOAD = ManagedVecItemPayloadBuffer<4>; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = ManagedRef<'a, M, Self>; @@ -200,7 +208,7 @@ impl ManagedVecItem for ManagedByteArray where M: ManagedTypeApi, { - const PAYLOAD_SIZE: usize = 4; + type PAYLOAD = ManagedVecItemPayloadBuffer<4>; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = ManagedRef<'a, M, Self>; @@ -224,56 +232,12 @@ where } } -impl ManagedVecItem for [T; N] -where - [(); T::PAYLOAD_SIZE * N]:, - T: ManagedVecItem, -{ - const PAYLOAD_SIZE: usize = T::PAYLOAD_SIZE * N; - const SKIPS_RESERIALIZATION: bool = T::SKIPS_RESERIALIZATION; - type Ref<'a> = Self; - - fn from_byte_reader(mut reader: Reader) -> Self { - let mut byte_arr: [u8; T::PAYLOAD_SIZE * N] = [0; T::PAYLOAD_SIZE * N]; - reader(&mut byte_arr[..]); - let mut result: [T; N] = unsafe { MaybeUninit::zeroed().assume_init() }; - let mut from_index = 0; - for item in result.iter_mut() { - let to_index = from_index + T::PAYLOAD_SIZE; - *item = T::from_byte_reader(|bytes| { - bytes.copy_from_slice(&byte_arr[from_index..to_index]); - }); - from_index = to_index; - } - result - } - - unsafe fn from_byte_reader_as_borrow<'a, Reader: FnMut(&mut [u8])>( - reader: Reader, - ) -> Self::Ref<'a> { - Self::from_byte_reader(reader) - } - - fn to_byte_writer R>(&self, mut writer: Writer) -> R { - let mut byte_arr: [u8; T::PAYLOAD_SIZE * N] = [0; T::PAYLOAD_SIZE * N]; - let mut from_index = 0; - for item in self { - let to_index = from_index + T::PAYLOAD_SIZE; - item.to_byte_writer(|bytes| { - byte_arr[from_index..to_index].copy_from_slice(bytes); - }); - from_index = to_index; - } - writer(&byte_arr[..]) - } -} - impl ManagedVecItem for ManagedVec where M: ManagedTypeApi, T: ManagedVecItem, { - const PAYLOAD_SIZE: usize = 4; + type PAYLOAD = ManagedVecItemPayloadBuffer<4>; const SKIPS_RESERIALIZATION: bool = false; type Ref<'a> = ManagedRef<'a, M, Self>; diff --git a/framework/base/src/types/managed/wrapped/managed_vec_item_nested_tuple.rs b/framework/base/src/types/managed/wrapped/managed_vec_item_nested_tuple.rs new file mode 100644 index 0000000000..3a25bf4993 --- /dev/null +++ b/framework/base/src/types/managed/wrapped/managed_vec_item_nested_tuple.rs @@ -0,0 +1,40 @@ +use super::{ + ManagedVecItem, ManagedVecItemEmptyPayload, ManagedVecItemPayload, ManagedVecItemPayloadAdd, +}; + +/// Syntactic sugar, that allows us to more easily represent composite payloads as nested tuples. +pub trait ManagedVecItemNestedTuple { + type PAYLOAD: ManagedVecItemPayload; +} + +/// End of the list. +impl ManagedVecItemNestedTuple for () { + type PAYLOAD = ManagedVecItemEmptyPayload; +} + +impl ManagedVecItemNestedTuple for (Head, Tail) +where + Head: ManagedVecItem, + Tail: ManagedVecItemNestedTuple, + Head::PAYLOAD: ManagedVecItemPayloadAdd, +{ + type PAYLOAD = >::Output; +} + +#[cfg(test)] +pub mod tests { + use super::*; + + #[test] + fn managed_vec_item_nesteds_tuple_test() { + assert_payload_size::<()>(0); + assert_payload_size::<(u8, ())>(1); + assert_payload_size::<(usize, ())>(4); + assert_payload_size::<(usize, (usize, ()))>(8); + assert_payload_size::<(Option, ())>(5); + } + + fn assert_payload_size(expected_size: usize) { + assert_eq!(N::PAYLOAD::payload_size(), expected_size); + } +} diff --git a/framework/base/src/types/managed/wrapped/managed_vec_item_payload.rs b/framework/base/src/types/managed/wrapped/managed_vec_item_payload.rs new file mode 100644 index 0000000000..f5bf96e4a4 --- /dev/null +++ b/framework/base/src/types/managed/wrapped/managed_vec_item_payload.rs @@ -0,0 +1,2391 @@ +/// Describes the binary represetnation of a ManagedVecItem. +/// +/// It is always an array that can be allocated directly on stack. +pub trait ManagedVecItemPayload { + fn new_buffer() -> Self; + + fn payload_size() -> usize; + + fn payload_slice(&self) -> &[u8]; + + fn payload_slice_mut(&mut self) -> &mut [u8]; +} + +/// Empty ManagedVecItem. +/// +/// Only used as type, never as implementation, since all ManagedVecItem have some data in them. +pub struct ManagedVecItemEmptyPayload; + +impl ManagedVecItemPayload for ManagedVecItemEmptyPayload { + fn new_buffer() -> Self { + ManagedVecItemEmptyPayload + } + + fn payload_size() -> usize { + 0 + } + + fn payload_slice(&self) -> &[u8] { + &[] + } + + fn payload_slice_mut(&mut self) -> &mut [u8] { + &mut [] + } +} + +/// The main ManagedVecItemPayload implementation. Uses an array in its implementation. +pub struct ManagedVecItemPayloadBuffer { + buffer: [u8; N], +} + +impl ManagedVecItemPayload for ManagedVecItemPayloadBuffer { + fn new_buffer() -> Self { + ManagedVecItemPayloadBuffer { buffer: [0u8; N] } + } + + fn payload_size() -> usize { + N + } + + fn payload_slice(&self) -> &[u8] { + &self.buffer[..] + } + + fn payload_slice_mut(&mut self) -> &mut [u8] { + &mut self.buffer[..] + } +} + +/// Describes concatantion of smaller payloads into a larger one. +/// +/// There is no runtime implementation, just a type-level addition. +/// +/// Implemented via macros, because generic const expressions are currently unstable. +pub trait ManagedVecItemPayloadAdd: ManagedVecItemPayload +where + Rhs: ManagedVecItemPayload, +{ + type Output: ManagedVecItemPayload; +} + +impl ManagedVecItemPayloadAdd + for ManagedVecItemPayloadBuffer +{ + type Output = Self; +} + +macro_rules! payload_add { + ($dec1:expr, $dec2:expr, $result_add:expr) => { + impl ManagedVecItemPayloadAdd> + for ManagedVecItemPayloadBuffer<$dec1> + { + type Output = ManagedVecItemPayloadBuffer<$result_add>; + } + }; +} + +payload_add!(1usize, 1usize, 2usize); +payload_add!(1usize, 2usize, 3usize); +payload_add!(1usize, 3usize, 4usize); +payload_add!(1usize, 4usize, 5usize); +payload_add!(1usize, 5usize, 6usize); +payload_add!(1usize, 6usize, 7usize); +payload_add!(1usize, 7usize, 8usize); +payload_add!(1usize, 8usize, 9usize); +payload_add!(1usize, 9usize, 10usize); +payload_add!(1usize, 10usize, 11usize); +payload_add!(1usize, 11usize, 12usize); +payload_add!(1usize, 12usize, 13usize); +payload_add!(1usize, 13usize, 14usize); +payload_add!(1usize, 14usize, 15usize); +payload_add!(1usize, 15usize, 16usize); +payload_add!(1usize, 16usize, 17usize); +payload_add!(1usize, 17usize, 18usize); +payload_add!(1usize, 18usize, 19usize); +payload_add!(1usize, 19usize, 20usize); +payload_add!(1usize, 20usize, 21usize); +payload_add!(1usize, 21usize, 22usize); +payload_add!(1usize, 22usize, 23usize); +payload_add!(1usize, 23usize, 24usize); +payload_add!(1usize, 24usize, 25usize); +payload_add!(1usize, 25usize, 26usize); +payload_add!(1usize, 26usize, 27usize); +payload_add!(1usize, 27usize, 28usize); +payload_add!(1usize, 28usize, 29usize); +payload_add!(1usize, 29usize, 30usize); +payload_add!(1usize, 30usize, 31usize); +payload_add!(1usize, 31usize, 32usize); +payload_add!(1usize, 32usize, 33usize); +payload_add!(1usize, 33usize, 34usize); +payload_add!(1usize, 34usize, 35usize); +payload_add!(1usize, 35usize, 36usize); +payload_add!(1usize, 36usize, 37usize); +payload_add!(1usize, 37usize, 38usize); +payload_add!(1usize, 38usize, 39usize); +payload_add!(1usize, 39usize, 40usize); +payload_add!(1usize, 40usize, 41usize); +payload_add!(1usize, 41usize, 42usize); +payload_add!(1usize, 42usize, 43usize); +payload_add!(1usize, 43usize, 44usize); +payload_add!(1usize, 44usize, 45usize); +payload_add!(1usize, 45usize, 46usize); +payload_add!(1usize, 46usize, 47usize); +payload_add!(1usize, 47usize, 48usize); +payload_add!(1usize, 48usize, 49usize); +payload_add!(2usize, 1usize, 3usize); +payload_add!(2usize, 2usize, 4usize); +payload_add!(2usize, 3usize, 5usize); +payload_add!(2usize, 4usize, 6usize); +payload_add!(2usize, 5usize, 7usize); +payload_add!(2usize, 6usize, 8usize); +payload_add!(2usize, 7usize, 9usize); +payload_add!(2usize, 8usize, 10usize); +payload_add!(2usize, 9usize, 11usize); +payload_add!(2usize, 10usize, 12usize); +payload_add!(2usize, 11usize, 13usize); +payload_add!(2usize, 12usize, 14usize); +payload_add!(2usize, 13usize, 15usize); +payload_add!(2usize, 14usize, 16usize); +payload_add!(2usize, 15usize, 17usize); +payload_add!(2usize, 16usize, 18usize); +payload_add!(2usize, 17usize, 19usize); +payload_add!(2usize, 18usize, 20usize); +payload_add!(2usize, 19usize, 21usize); +payload_add!(2usize, 20usize, 22usize); +payload_add!(2usize, 21usize, 23usize); +payload_add!(2usize, 22usize, 24usize); +payload_add!(2usize, 23usize, 25usize); +payload_add!(2usize, 24usize, 26usize); +payload_add!(2usize, 25usize, 27usize); +payload_add!(2usize, 26usize, 28usize); +payload_add!(2usize, 27usize, 29usize); +payload_add!(2usize, 28usize, 30usize); +payload_add!(2usize, 29usize, 31usize); +payload_add!(2usize, 30usize, 32usize); +payload_add!(2usize, 31usize, 33usize); +payload_add!(2usize, 32usize, 34usize); +payload_add!(2usize, 33usize, 35usize); +payload_add!(2usize, 34usize, 36usize); +payload_add!(2usize, 35usize, 37usize); +payload_add!(2usize, 36usize, 38usize); +payload_add!(2usize, 37usize, 39usize); +payload_add!(2usize, 38usize, 40usize); +payload_add!(2usize, 39usize, 41usize); +payload_add!(2usize, 40usize, 42usize); +payload_add!(2usize, 41usize, 43usize); +payload_add!(2usize, 42usize, 44usize); +payload_add!(2usize, 43usize, 45usize); +payload_add!(2usize, 44usize, 46usize); +payload_add!(2usize, 45usize, 47usize); +payload_add!(2usize, 46usize, 48usize); +payload_add!(2usize, 47usize, 49usize); +payload_add!(2usize, 48usize, 50usize); +payload_add!(3usize, 1usize, 4usize); +payload_add!(3usize, 2usize, 5usize); +payload_add!(3usize, 3usize, 6usize); +payload_add!(3usize, 4usize, 7usize); +payload_add!(3usize, 5usize, 8usize); +payload_add!(3usize, 6usize, 9usize); +payload_add!(3usize, 7usize, 10usize); +payload_add!(3usize, 8usize, 11usize); +payload_add!(3usize, 9usize, 12usize); +payload_add!(3usize, 10usize, 13usize); +payload_add!(3usize, 11usize, 14usize); +payload_add!(3usize, 12usize, 15usize); +payload_add!(3usize, 13usize, 16usize); +payload_add!(3usize, 14usize, 17usize); +payload_add!(3usize, 15usize, 18usize); +payload_add!(3usize, 16usize, 19usize); +payload_add!(3usize, 17usize, 20usize); +payload_add!(3usize, 18usize, 21usize); +payload_add!(3usize, 19usize, 22usize); +payload_add!(3usize, 20usize, 23usize); +payload_add!(3usize, 21usize, 24usize); +payload_add!(3usize, 22usize, 25usize); +payload_add!(3usize, 23usize, 26usize); +payload_add!(3usize, 24usize, 27usize); +payload_add!(3usize, 25usize, 28usize); +payload_add!(3usize, 26usize, 29usize); +payload_add!(3usize, 27usize, 30usize); +payload_add!(3usize, 28usize, 31usize); +payload_add!(3usize, 29usize, 32usize); +payload_add!(3usize, 30usize, 33usize); +payload_add!(3usize, 31usize, 34usize); +payload_add!(3usize, 32usize, 35usize); +payload_add!(3usize, 33usize, 36usize); +payload_add!(3usize, 34usize, 37usize); +payload_add!(3usize, 35usize, 38usize); +payload_add!(3usize, 36usize, 39usize); +payload_add!(3usize, 37usize, 40usize); +payload_add!(3usize, 38usize, 41usize); +payload_add!(3usize, 39usize, 42usize); +payload_add!(3usize, 40usize, 43usize); +payload_add!(3usize, 41usize, 44usize); +payload_add!(3usize, 42usize, 45usize); +payload_add!(3usize, 43usize, 46usize); +payload_add!(3usize, 44usize, 47usize); +payload_add!(3usize, 45usize, 48usize); +payload_add!(3usize, 46usize, 49usize); +payload_add!(3usize, 47usize, 50usize); +payload_add!(3usize, 48usize, 51usize); +payload_add!(4usize, 1usize, 5usize); +payload_add!(4usize, 2usize, 6usize); +payload_add!(4usize, 3usize, 7usize); +payload_add!(4usize, 4usize, 8usize); +payload_add!(4usize, 5usize, 9usize); +payload_add!(4usize, 6usize, 10usize); +payload_add!(4usize, 7usize, 11usize); +payload_add!(4usize, 8usize, 12usize); +payload_add!(4usize, 9usize, 13usize); +payload_add!(4usize, 10usize, 14usize); +payload_add!(4usize, 11usize, 15usize); +payload_add!(4usize, 12usize, 16usize); +payload_add!(4usize, 13usize, 17usize); +payload_add!(4usize, 14usize, 18usize); +payload_add!(4usize, 15usize, 19usize); +payload_add!(4usize, 16usize, 20usize); +payload_add!(4usize, 17usize, 21usize); +payload_add!(4usize, 18usize, 22usize); +payload_add!(4usize, 19usize, 23usize); +payload_add!(4usize, 20usize, 24usize); +payload_add!(4usize, 21usize, 25usize); +payload_add!(4usize, 22usize, 26usize); +payload_add!(4usize, 23usize, 27usize); +payload_add!(4usize, 24usize, 28usize); +payload_add!(4usize, 25usize, 29usize); +payload_add!(4usize, 26usize, 30usize); +payload_add!(4usize, 27usize, 31usize); +payload_add!(4usize, 28usize, 32usize); +payload_add!(4usize, 29usize, 33usize); +payload_add!(4usize, 30usize, 34usize); +payload_add!(4usize, 31usize, 35usize); +payload_add!(4usize, 32usize, 36usize); +payload_add!(4usize, 33usize, 37usize); +payload_add!(4usize, 34usize, 38usize); +payload_add!(4usize, 35usize, 39usize); +payload_add!(4usize, 36usize, 40usize); +payload_add!(4usize, 37usize, 41usize); +payload_add!(4usize, 38usize, 42usize); +payload_add!(4usize, 39usize, 43usize); +payload_add!(4usize, 40usize, 44usize); +payload_add!(4usize, 41usize, 45usize); +payload_add!(4usize, 42usize, 46usize); +payload_add!(4usize, 43usize, 47usize); +payload_add!(4usize, 44usize, 48usize); +payload_add!(4usize, 45usize, 49usize); +payload_add!(4usize, 46usize, 50usize); +payload_add!(4usize, 47usize, 51usize); +payload_add!(4usize, 48usize, 52usize); +payload_add!(5usize, 1usize, 6usize); +payload_add!(5usize, 2usize, 7usize); +payload_add!(5usize, 3usize, 8usize); +payload_add!(5usize, 4usize, 9usize); +payload_add!(5usize, 5usize, 10usize); +payload_add!(5usize, 6usize, 11usize); +payload_add!(5usize, 7usize, 12usize); +payload_add!(5usize, 8usize, 13usize); +payload_add!(5usize, 9usize, 14usize); +payload_add!(5usize, 10usize, 15usize); +payload_add!(5usize, 11usize, 16usize); +payload_add!(5usize, 12usize, 17usize); +payload_add!(5usize, 13usize, 18usize); +payload_add!(5usize, 14usize, 19usize); +payload_add!(5usize, 15usize, 20usize); +payload_add!(5usize, 16usize, 21usize); +payload_add!(5usize, 17usize, 22usize); +payload_add!(5usize, 18usize, 23usize); +payload_add!(5usize, 19usize, 24usize); +payload_add!(5usize, 20usize, 25usize); +payload_add!(5usize, 21usize, 26usize); +payload_add!(5usize, 22usize, 27usize); +payload_add!(5usize, 23usize, 28usize); +payload_add!(5usize, 24usize, 29usize); +payload_add!(5usize, 25usize, 30usize); +payload_add!(5usize, 26usize, 31usize); +payload_add!(5usize, 27usize, 32usize); +payload_add!(5usize, 28usize, 33usize); +payload_add!(5usize, 29usize, 34usize); +payload_add!(5usize, 30usize, 35usize); +payload_add!(5usize, 31usize, 36usize); +payload_add!(5usize, 32usize, 37usize); +payload_add!(5usize, 33usize, 38usize); +payload_add!(5usize, 34usize, 39usize); +payload_add!(5usize, 35usize, 40usize); +payload_add!(5usize, 36usize, 41usize); +payload_add!(5usize, 37usize, 42usize); +payload_add!(5usize, 38usize, 43usize); +payload_add!(5usize, 39usize, 44usize); +payload_add!(5usize, 40usize, 45usize); +payload_add!(5usize, 41usize, 46usize); +payload_add!(5usize, 42usize, 47usize); +payload_add!(5usize, 43usize, 48usize); +payload_add!(5usize, 44usize, 49usize); +payload_add!(5usize, 45usize, 50usize); +payload_add!(5usize, 46usize, 51usize); +payload_add!(5usize, 47usize, 52usize); +payload_add!(5usize, 48usize, 53usize); +payload_add!(6usize, 1usize, 7usize); +payload_add!(6usize, 2usize, 8usize); +payload_add!(6usize, 3usize, 9usize); +payload_add!(6usize, 4usize, 10usize); +payload_add!(6usize, 5usize, 11usize); +payload_add!(6usize, 6usize, 12usize); +payload_add!(6usize, 7usize, 13usize); +payload_add!(6usize, 8usize, 14usize); +payload_add!(6usize, 9usize, 15usize); +payload_add!(6usize, 10usize, 16usize); +payload_add!(6usize, 11usize, 17usize); +payload_add!(6usize, 12usize, 18usize); +payload_add!(6usize, 13usize, 19usize); +payload_add!(6usize, 14usize, 20usize); +payload_add!(6usize, 15usize, 21usize); +payload_add!(6usize, 16usize, 22usize); +payload_add!(6usize, 17usize, 23usize); +payload_add!(6usize, 18usize, 24usize); +payload_add!(6usize, 19usize, 25usize); +payload_add!(6usize, 20usize, 26usize); +payload_add!(6usize, 21usize, 27usize); +payload_add!(6usize, 22usize, 28usize); +payload_add!(6usize, 23usize, 29usize); +payload_add!(6usize, 24usize, 30usize); +payload_add!(6usize, 25usize, 31usize); +payload_add!(6usize, 26usize, 32usize); +payload_add!(6usize, 27usize, 33usize); +payload_add!(6usize, 28usize, 34usize); +payload_add!(6usize, 29usize, 35usize); +payload_add!(6usize, 30usize, 36usize); +payload_add!(6usize, 31usize, 37usize); +payload_add!(6usize, 32usize, 38usize); +payload_add!(6usize, 33usize, 39usize); +payload_add!(6usize, 34usize, 40usize); +payload_add!(6usize, 35usize, 41usize); +payload_add!(6usize, 36usize, 42usize); +payload_add!(6usize, 37usize, 43usize); +payload_add!(6usize, 38usize, 44usize); +payload_add!(6usize, 39usize, 45usize); +payload_add!(6usize, 40usize, 46usize); +payload_add!(6usize, 41usize, 47usize); +payload_add!(6usize, 42usize, 48usize); +payload_add!(6usize, 43usize, 49usize); +payload_add!(6usize, 44usize, 50usize); +payload_add!(6usize, 45usize, 51usize); +payload_add!(6usize, 46usize, 52usize); +payload_add!(6usize, 47usize, 53usize); +payload_add!(6usize, 48usize, 54usize); +payload_add!(7usize, 1usize, 8usize); +payload_add!(7usize, 2usize, 9usize); +payload_add!(7usize, 3usize, 10usize); +payload_add!(7usize, 4usize, 11usize); +payload_add!(7usize, 5usize, 12usize); +payload_add!(7usize, 6usize, 13usize); +payload_add!(7usize, 7usize, 14usize); +payload_add!(7usize, 8usize, 15usize); +payload_add!(7usize, 9usize, 16usize); +payload_add!(7usize, 10usize, 17usize); +payload_add!(7usize, 11usize, 18usize); +payload_add!(7usize, 12usize, 19usize); +payload_add!(7usize, 13usize, 20usize); +payload_add!(7usize, 14usize, 21usize); +payload_add!(7usize, 15usize, 22usize); +payload_add!(7usize, 16usize, 23usize); +payload_add!(7usize, 17usize, 24usize); +payload_add!(7usize, 18usize, 25usize); +payload_add!(7usize, 19usize, 26usize); +payload_add!(7usize, 20usize, 27usize); +payload_add!(7usize, 21usize, 28usize); +payload_add!(7usize, 22usize, 29usize); +payload_add!(7usize, 23usize, 30usize); +payload_add!(7usize, 24usize, 31usize); +payload_add!(7usize, 25usize, 32usize); +payload_add!(7usize, 26usize, 33usize); +payload_add!(7usize, 27usize, 34usize); +payload_add!(7usize, 28usize, 35usize); +payload_add!(7usize, 29usize, 36usize); +payload_add!(7usize, 30usize, 37usize); +payload_add!(7usize, 31usize, 38usize); +payload_add!(7usize, 32usize, 39usize); +payload_add!(7usize, 33usize, 40usize); +payload_add!(7usize, 34usize, 41usize); +payload_add!(7usize, 35usize, 42usize); +payload_add!(7usize, 36usize, 43usize); +payload_add!(7usize, 37usize, 44usize); +payload_add!(7usize, 38usize, 45usize); +payload_add!(7usize, 39usize, 46usize); +payload_add!(7usize, 40usize, 47usize); +payload_add!(7usize, 41usize, 48usize); +payload_add!(7usize, 42usize, 49usize); +payload_add!(7usize, 43usize, 50usize); +payload_add!(7usize, 44usize, 51usize); +payload_add!(7usize, 45usize, 52usize); +payload_add!(7usize, 46usize, 53usize); +payload_add!(7usize, 47usize, 54usize); +payload_add!(7usize, 48usize, 55usize); +payload_add!(8usize, 1usize, 9usize); +payload_add!(8usize, 2usize, 10usize); +payload_add!(8usize, 3usize, 11usize); +payload_add!(8usize, 4usize, 12usize); +payload_add!(8usize, 5usize, 13usize); +payload_add!(8usize, 6usize, 14usize); +payload_add!(8usize, 7usize, 15usize); +payload_add!(8usize, 8usize, 16usize); +payload_add!(8usize, 9usize, 17usize); +payload_add!(8usize, 10usize, 18usize); +payload_add!(8usize, 11usize, 19usize); +payload_add!(8usize, 12usize, 20usize); +payload_add!(8usize, 13usize, 21usize); +payload_add!(8usize, 14usize, 22usize); +payload_add!(8usize, 15usize, 23usize); +payload_add!(8usize, 16usize, 24usize); +payload_add!(8usize, 17usize, 25usize); +payload_add!(8usize, 18usize, 26usize); +payload_add!(8usize, 19usize, 27usize); +payload_add!(8usize, 20usize, 28usize); +payload_add!(8usize, 21usize, 29usize); +payload_add!(8usize, 22usize, 30usize); +payload_add!(8usize, 23usize, 31usize); +payload_add!(8usize, 24usize, 32usize); +payload_add!(8usize, 25usize, 33usize); +payload_add!(8usize, 26usize, 34usize); +payload_add!(8usize, 27usize, 35usize); +payload_add!(8usize, 28usize, 36usize); +payload_add!(8usize, 29usize, 37usize); +payload_add!(8usize, 30usize, 38usize); +payload_add!(8usize, 31usize, 39usize); +payload_add!(8usize, 32usize, 40usize); +payload_add!(8usize, 33usize, 41usize); +payload_add!(8usize, 34usize, 42usize); +payload_add!(8usize, 35usize, 43usize); +payload_add!(8usize, 36usize, 44usize); +payload_add!(8usize, 37usize, 45usize); +payload_add!(8usize, 38usize, 46usize); +payload_add!(8usize, 39usize, 47usize); +payload_add!(8usize, 40usize, 48usize); +payload_add!(8usize, 41usize, 49usize); +payload_add!(8usize, 42usize, 50usize); +payload_add!(8usize, 43usize, 51usize); +payload_add!(8usize, 44usize, 52usize); +payload_add!(8usize, 45usize, 53usize); +payload_add!(8usize, 46usize, 54usize); +payload_add!(8usize, 47usize, 55usize); +payload_add!(8usize, 48usize, 56usize); +payload_add!(9usize, 1usize, 10usize); +payload_add!(9usize, 2usize, 11usize); +payload_add!(9usize, 3usize, 12usize); +payload_add!(9usize, 4usize, 13usize); +payload_add!(9usize, 5usize, 14usize); +payload_add!(9usize, 6usize, 15usize); +payload_add!(9usize, 7usize, 16usize); +payload_add!(9usize, 8usize, 17usize); +payload_add!(9usize, 9usize, 18usize); +payload_add!(9usize, 10usize, 19usize); +payload_add!(9usize, 11usize, 20usize); +payload_add!(9usize, 12usize, 21usize); +payload_add!(9usize, 13usize, 22usize); +payload_add!(9usize, 14usize, 23usize); +payload_add!(9usize, 15usize, 24usize); +payload_add!(9usize, 16usize, 25usize); +payload_add!(9usize, 17usize, 26usize); +payload_add!(9usize, 18usize, 27usize); +payload_add!(9usize, 19usize, 28usize); +payload_add!(9usize, 20usize, 29usize); +payload_add!(9usize, 21usize, 30usize); +payload_add!(9usize, 22usize, 31usize); +payload_add!(9usize, 23usize, 32usize); +payload_add!(9usize, 24usize, 33usize); +payload_add!(9usize, 25usize, 34usize); +payload_add!(9usize, 26usize, 35usize); +payload_add!(9usize, 27usize, 36usize); +payload_add!(9usize, 28usize, 37usize); +payload_add!(9usize, 29usize, 38usize); +payload_add!(9usize, 30usize, 39usize); +payload_add!(9usize, 31usize, 40usize); +payload_add!(9usize, 32usize, 41usize); +payload_add!(9usize, 33usize, 42usize); +payload_add!(9usize, 34usize, 43usize); +payload_add!(9usize, 35usize, 44usize); +payload_add!(9usize, 36usize, 45usize); +payload_add!(9usize, 37usize, 46usize); +payload_add!(9usize, 38usize, 47usize); +payload_add!(9usize, 39usize, 48usize); +payload_add!(9usize, 40usize, 49usize); +payload_add!(9usize, 41usize, 50usize); +payload_add!(9usize, 42usize, 51usize); +payload_add!(9usize, 43usize, 52usize); +payload_add!(9usize, 44usize, 53usize); +payload_add!(9usize, 45usize, 54usize); +payload_add!(9usize, 46usize, 55usize); +payload_add!(9usize, 47usize, 56usize); +payload_add!(9usize, 48usize, 57usize); +payload_add!(10usize, 1usize, 11usize); +payload_add!(10usize, 2usize, 12usize); +payload_add!(10usize, 3usize, 13usize); +payload_add!(10usize, 4usize, 14usize); +payload_add!(10usize, 5usize, 15usize); +payload_add!(10usize, 6usize, 16usize); +payload_add!(10usize, 7usize, 17usize); +payload_add!(10usize, 8usize, 18usize); +payload_add!(10usize, 9usize, 19usize); +payload_add!(10usize, 10usize, 20usize); +payload_add!(10usize, 11usize, 21usize); +payload_add!(10usize, 12usize, 22usize); +payload_add!(10usize, 13usize, 23usize); +payload_add!(10usize, 14usize, 24usize); +payload_add!(10usize, 15usize, 25usize); +payload_add!(10usize, 16usize, 26usize); +payload_add!(10usize, 17usize, 27usize); +payload_add!(10usize, 18usize, 28usize); +payload_add!(10usize, 19usize, 29usize); +payload_add!(10usize, 20usize, 30usize); +payload_add!(10usize, 21usize, 31usize); +payload_add!(10usize, 22usize, 32usize); +payload_add!(10usize, 23usize, 33usize); +payload_add!(10usize, 24usize, 34usize); +payload_add!(10usize, 25usize, 35usize); +payload_add!(10usize, 26usize, 36usize); +payload_add!(10usize, 27usize, 37usize); +payload_add!(10usize, 28usize, 38usize); +payload_add!(10usize, 29usize, 39usize); +payload_add!(10usize, 30usize, 40usize); +payload_add!(10usize, 31usize, 41usize); +payload_add!(10usize, 32usize, 42usize); +payload_add!(10usize, 33usize, 43usize); +payload_add!(10usize, 34usize, 44usize); +payload_add!(10usize, 35usize, 45usize); +payload_add!(10usize, 36usize, 46usize); +payload_add!(10usize, 37usize, 47usize); +payload_add!(10usize, 38usize, 48usize); +payload_add!(10usize, 39usize, 49usize); +payload_add!(10usize, 40usize, 50usize); +payload_add!(10usize, 41usize, 51usize); +payload_add!(10usize, 42usize, 52usize); +payload_add!(10usize, 43usize, 53usize); +payload_add!(10usize, 44usize, 54usize); +payload_add!(10usize, 45usize, 55usize); +payload_add!(10usize, 46usize, 56usize); +payload_add!(10usize, 47usize, 57usize); +payload_add!(10usize, 48usize, 58usize); +payload_add!(11usize, 1usize, 12usize); +payload_add!(11usize, 2usize, 13usize); +payload_add!(11usize, 3usize, 14usize); +payload_add!(11usize, 4usize, 15usize); +payload_add!(11usize, 5usize, 16usize); +payload_add!(11usize, 6usize, 17usize); +payload_add!(11usize, 7usize, 18usize); +payload_add!(11usize, 8usize, 19usize); +payload_add!(11usize, 9usize, 20usize); +payload_add!(11usize, 10usize, 21usize); +payload_add!(11usize, 11usize, 22usize); +payload_add!(11usize, 12usize, 23usize); +payload_add!(11usize, 13usize, 24usize); +payload_add!(11usize, 14usize, 25usize); +payload_add!(11usize, 15usize, 26usize); +payload_add!(11usize, 16usize, 27usize); +payload_add!(11usize, 17usize, 28usize); +payload_add!(11usize, 18usize, 29usize); +payload_add!(11usize, 19usize, 30usize); +payload_add!(11usize, 20usize, 31usize); +payload_add!(11usize, 21usize, 32usize); +payload_add!(11usize, 22usize, 33usize); +payload_add!(11usize, 23usize, 34usize); +payload_add!(11usize, 24usize, 35usize); +payload_add!(11usize, 25usize, 36usize); +payload_add!(11usize, 26usize, 37usize); +payload_add!(11usize, 27usize, 38usize); +payload_add!(11usize, 28usize, 39usize); +payload_add!(11usize, 29usize, 40usize); +payload_add!(11usize, 30usize, 41usize); +payload_add!(11usize, 31usize, 42usize); +payload_add!(11usize, 32usize, 43usize); +payload_add!(11usize, 33usize, 44usize); +payload_add!(11usize, 34usize, 45usize); +payload_add!(11usize, 35usize, 46usize); +payload_add!(11usize, 36usize, 47usize); +payload_add!(11usize, 37usize, 48usize); +payload_add!(11usize, 38usize, 49usize); +payload_add!(11usize, 39usize, 50usize); +payload_add!(11usize, 40usize, 51usize); +payload_add!(11usize, 41usize, 52usize); +payload_add!(11usize, 42usize, 53usize); +payload_add!(11usize, 43usize, 54usize); +payload_add!(11usize, 44usize, 55usize); +payload_add!(11usize, 45usize, 56usize); +payload_add!(11usize, 46usize, 57usize); +payload_add!(11usize, 47usize, 58usize); +payload_add!(11usize, 48usize, 59usize); +payload_add!(12usize, 1usize, 13usize); +payload_add!(12usize, 2usize, 14usize); +payload_add!(12usize, 3usize, 15usize); +payload_add!(12usize, 4usize, 16usize); +payload_add!(12usize, 5usize, 17usize); +payload_add!(12usize, 6usize, 18usize); +payload_add!(12usize, 7usize, 19usize); +payload_add!(12usize, 8usize, 20usize); +payload_add!(12usize, 9usize, 21usize); +payload_add!(12usize, 10usize, 22usize); +payload_add!(12usize, 11usize, 23usize); +payload_add!(12usize, 12usize, 24usize); +payload_add!(12usize, 13usize, 25usize); +payload_add!(12usize, 14usize, 26usize); +payload_add!(12usize, 15usize, 27usize); +payload_add!(12usize, 16usize, 28usize); +payload_add!(12usize, 17usize, 29usize); +payload_add!(12usize, 18usize, 30usize); +payload_add!(12usize, 19usize, 31usize); +payload_add!(12usize, 20usize, 32usize); +payload_add!(12usize, 21usize, 33usize); +payload_add!(12usize, 22usize, 34usize); +payload_add!(12usize, 23usize, 35usize); +payload_add!(12usize, 24usize, 36usize); +payload_add!(12usize, 25usize, 37usize); +payload_add!(12usize, 26usize, 38usize); +payload_add!(12usize, 27usize, 39usize); +payload_add!(12usize, 28usize, 40usize); +payload_add!(12usize, 29usize, 41usize); +payload_add!(12usize, 30usize, 42usize); +payload_add!(12usize, 31usize, 43usize); +payload_add!(12usize, 32usize, 44usize); +payload_add!(12usize, 33usize, 45usize); +payload_add!(12usize, 34usize, 46usize); +payload_add!(12usize, 35usize, 47usize); +payload_add!(12usize, 36usize, 48usize); +payload_add!(12usize, 37usize, 49usize); +payload_add!(12usize, 38usize, 50usize); +payload_add!(12usize, 39usize, 51usize); +payload_add!(12usize, 40usize, 52usize); +payload_add!(12usize, 41usize, 53usize); +payload_add!(12usize, 42usize, 54usize); +payload_add!(12usize, 43usize, 55usize); +payload_add!(12usize, 44usize, 56usize); +payload_add!(12usize, 45usize, 57usize); +payload_add!(12usize, 46usize, 58usize); +payload_add!(12usize, 47usize, 59usize); +payload_add!(12usize, 48usize, 60usize); +payload_add!(13usize, 1usize, 14usize); +payload_add!(13usize, 2usize, 15usize); +payload_add!(13usize, 3usize, 16usize); +payload_add!(13usize, 4usize, 17usize); +payload_add!(13usize, 5usize, 18usize); +payload_add!(13usize, 6usize, 19usize); +payload_add!(13usize, 7usize, 20usize); +payload_add!(13usize, 8usize, 21usize); +payload_add!(13usize, 9usize, 22usize); +payload_add!(13usize, 10usize, 23usize); +payload_add!(13usize, 11usize, 24usize); +payload_add!(13usize, 12usize, 25usize); +payload_add!(13usize, 13usize, 26usize); +payload_add!(13usize, 14usize, 27usize); +payload_add!(13usize, 15usize, 28usize); +payload_add!(13usize, 16usize, 29usize); +payload_add!(13usize, 17usize, 30usize); +payload_add!(13usize, 18usize, 31usize); +payload_add!(13usize, 19usize, 32usize); +payload_add!(13usize, 20usize, 33usize); +payload_add!(13usize, 21usize, 34usize); +payload_add!(13usize, 22usize, 35usize); +payload_add!(13usize, 23usize, 36usize); +payload_add!(13usize, 24usize, 37usize); +payload_add!(13usize, 25usize, 38usize); +payload_add!(13usize, 26usize, 39usize); +payload_add!(13usize, 27usize, 40usize); +payload_add!(13usize, 28usize, 41usize); +payload_add!(13usize, 29usize, 42usize); +payload_add!(13usize, 30usize, 43usize); +payload_add!(13usize, 31usize, 44usize); +payload_add!(13usize, 32usize, 45usize); +payload_add!(13usize, 33usize, 46usize); +payload_add!(13usize, 34usize, 47usize); +payload_add!(13usize, 35usize, 48usize); +payload_add!(13usize, 36usize, 49usize); +payload_add!(13usize, 37usize, 50usize); +payload_add!(13usize, 38usize, 51usize); +payload_add!(13usize, 39usize, 52usize); +payload_add!(13usize, 40usize, 53usize); +payload_add!(13usize, 41usize, 54usize); +payload_add!(13usize, 42usize, 55usize); +payload_add!(13usize, 43usize, 56usize); +payload_add!(13usize, 44usize, 57usize); +payload_add!(13usize, 45usize, 58usize); +payload_add!(13usize, 46usize, 59usize); +payload_add!(13usize, 47usize, 60usize); +payload_add!(13usize, 48usize, 61usize); +payload_add!(14usize, 1usize, 15usize); +payload_add!(14usize, 2usize, 16usize); +payload_add!(14usize, 3usize, 17usize); +payload_add!(14usize, 4usize, 18usize); +payload_add!(14usize, 5usize, 19usize); +payload_add!(14usize, 6usize, 20usize); +payload_add!(14usize, 7usize, 21usize); +payload_add!(14usize, 8usize, 22usize); +payload_add!(14usize, 9usize, 23usize); +payload_add!(14usize, 10usize, 24usize); +payload_add!(14usize, 11usize, 25usize); +payload_add!(14usize, 12usize, 26usize); +payload_add!(14usize, 13usize, 27usize); +payload_add!(14usize, 14usize, 28usize); +payload_add!(14usize, 15usize, 29usize); +payload_add!(14usize, 16usize, 30usize); +payload_add!(14usize, 17usize, 31usize); +payload_add!(14usize, 18usize, 32usize); +payload_add!(14usize, 19usize, 33usize); +payload_add!(14usize, 20usize, 34usize); +payload_add!(14usize, 21usize, 35usize); +payload_add!(14usize, 22usize, 36usize); +payload_add!(14usize, 23usize, 37usize); +payload_add!(14usize, 24usize, 38usize); +payload_add!(14usize, 25usize, 39usize); +payload_add!(14usize, 26usize, 40usize); +payload_add!(14usize, 27usize, 41usize); +payload_add!(14usize, 28usize, 42usize); +payload_add!(14usize, 29usize, 43usize); +payload_add!(14usize, 30usize, 44usize); +payload_add!(14usize, 31usize, 45usize); +payload_add!(14usize, 32usize, 46usize); +payload_add!(14usize, 33usize, 47usize); +payload_add!(14usize, 34usize, 48usize); +payload_add!(14usize, 35usize, 49usize); +payload_add!(14usize, 36usize, 50usize); +payload_add!(14usize, 37usize, 51usize); +payload_add!(14usize, 38usize, 52usize); +payload_add!(14usize, 39usize, 53usize); +payload_add!(14usize, 40usize, 54usize); +payload_add!(14usize, 41usize, 55usize); +payload_add!(14usize, 42usize, 56usize); +payload_add!(14usize, 43usize, 57usize); +payload_add!(14usize, 44usize, 58usize); +payload_add!(14usize, 45usize, 59usize); +payload_add!(14usize, 46usize, 60usize); +payload_add!(14usize, 47usize, 61usize); +payload_add!(14usize, 48usize, 62usize); +payload_add!(15usize, 1usize, 16usize); +payload_add!(15usize, 2usize, 17usize); +payload_add!(15usize, 3usize, 18usize); +payload_add!(15usize, 4usize, 19usize); +payload_add!(15usize, 5usize, 20usize); +payload_add!(15usize, 6usize, 21usize); +payload_add!(15usize, 7usize, 22usize); +payload_add!(15usize, 8usize, 23usize); +payload_add!(15usize, 9usize, 24usize); +payload_add!(15usize, 10usize, 25usize); +payload_add!(15usize, 11usize, 26usize); +payload_add!(15usize, 12usize, 27usize); +payload_add!(15usize, 13usize, 28usize); +payload_add!(15usize, 14usize, 29usize); +payload_add!(15usize, 15usize, 30usize); +payload_add!(15usize, 16usize, 31usize); +payload_add!(15usize, 17usize, 32usize); +payload_add!(15usize, 18usize, 33usize); +payload_add!(15usize, 19usize, 34usize); +payload_add!(15usize, 20usize, 35usize); +payload_add!(15usize, 21usize, 36usize); +payload_add!(15usize, 22usize, 37usize); +payload_add!(15usize, 23usize, 38usize); +payload_add!(15usize, 24usize, 39usize); +payload_add!(15usize, 25usize, 40usize); +payload_add!(15usize, 26usize, 41usize); +payload_add!(15usize, 27usize, 42usize); +payload_add!(15usize, 28usize, 43usize); +payload_add!(15usize, 29usize, 44usize); +payload_add!(15usize, 30usize, 45usize); +payload_add!(15usize, 31usize, 46usize); +payload_add!(15usize, 32usize, 47usize); +payload_add!(15usize, 33usize, 48usize); +payload_add!(15usize, 34usize, 49usize); +payload_add!(15usize, 35usize, 50usize); +payload_add!(15usize, 36usize, 51usize); +payload_add!(15usize, 37usize, 52usize); +payload_add!(15usize, 38usize, 53usize); +payload_add!(15usize, 39usize, 54usize); +payload_add!(15usize, 40usize, 55usize); +payload_add!(15usize, 41usize, 56usize); +payload_add!(15usize, 42usize, 57usize); +payload_add!(15usize, 43usize, 58usize); +payload_add!(15usize, 44usize, 59usize); +payload_add!(15usize, 45usize, 60usize); +payload_add!(15usize, 46usize, 61usize); +payload_add!(15usize, 47usize, 62usize); +payload_add!(15usize, 48usize, 63usize); +payload_add!(16usize, 1usize, 17usize); +payload_add!(16usize, 2usize, 18usize); +payload_add!(16usize, 3usize, 19usize); +payload_add!(16usize, 4usize, 20usize); +payload_add!(16usize, 5usize, 21usize); +payload_add!(16usize, 6usize, 22usize); +payload_add!(16usize, 7usize, 23usize); +payload_add!(16usize, 8usize, 24usize); +payload_add!(16usize, 9usize, 25usize); +payload_add!(16usize, 10usize, 26usize); +payload_add!(16usize, 11usize, 27usize); +payload_add!(16usize, 12usize, 28usize); +payload_add!(16usize, 13usize, 29usize); +payload_add!(16usize, 14usize, 30usize); +payload_add!(16usize, 15usize, 31usize); +payload_add!(16usize, 16usize, 32usize); +payload_add!(16usize, 17usize, 33usize); +payload_add!(16usize, 18usize, 34usize); +payload_add!(16usize, 19usize, 35usize); +payload_add!(16usize, 20usize, 36usize); +payload_add!(16usize, 21usize, 37usize); +payload_add!(16usize, 22usize, 38usize); +payload_add!(16usize, 23usize, 39usize); +payload_add!(16usize, 24usize, 40usize); +payload_add!(16usize, 25usize, 41usize); +payload_add!(16usize, 26usize, 42usize); +payload_add!(16usize, 27usize, 43usize); +payload_add!(16usize, 28usize, 44usize); +payload_add!(16usize, 29usize, 45usize); +payload_add!(16usize, 30usize, 46usize); +payload_add!(16usize, 31usize, 47usize); +payload_add!(16usize, 32usize, 48usize); +payload_add!(16usize, 33usize, 49usize); +payload_add!(16usize, 34usize, 50usize); +payload_add!(16usize, 35usize, 51usize); +payload_add!(16usize, 36usize, 52usize); +payload_add!(16usize, 37usize, 53usize); +payload_add!(16usize, 38usize, 54usize); +payload_add!(16usize, 39usize, 55usize); +payload_add!(16usize, 40usize, 56usize); +payload_add!(16usize, 41usize, 57usize); +payload_add!(16usize, 42usize, 58usize); +payload_add!(16usize, 43usize, 59usize); +payload_add!(16usize, 44usize, 60usize); +payload_add!(16usize, 45usize, 61usize); +payload_add!(16usize, 46usize, 62usize); +payload_add!(16usize, 47usize, 63usize); +payload_add!(16usize, 48usize, 64usize); +payload_add!(17usize, 1usize, 18usize); +payload_add!(17usize, 2usize, 19usize); +payload_add!(17usize, 3usize, 20usize); +payload_add!(17usize, 4usize, 21usize); +payload_add!(17usize, 5usize, 22usize); +payload_add!(17usize, 6usize, 23usize); +payload_add!(17usize, 7usize, 24usize); +payload_add!(17usize, 8usize, 25usize); +payload_add!(17usize, 9usize, 26usize); +payload_add!(17usize, 10usize, 27usize); +payload_add!(17usize, 11usize, 28usize); +payload_add!(17usize, 12usize, 29usize); +payload_add!(17usize, 13usize, 30usize); +payload_add!(17usize, 14usize, 31usize); +payload_add!(17usize, 15usize, 32usize); +payload_add!(17usize, 16usize, 33usize); +payload_add!(17usize, 17usize, 34usize); +payload_add!(17usize, 18usize, 35usize); +payload_add!(17usize, 19usize, 36usize); +payload_add!(17usize, 20usize, 37usize); +payload_add!(17usize, 21usize, 38usize); +payload_add!(17usize, 22usize, 39usize); +payload_add!(17usize, 23usize, 40usize); +payload_add!(17usize, 24usize, 41usize); +payload_add!(17usize, 25usize, 42usize); +payload_add!(17usize, 26usize, 43usize); +payload_add!(17usize, 27usize, 44usize); +payload_add!(17usize, 28usize, 45usize); +payload_add!(17usize, 29usize, 46usize); +payload_add!(17usize, 30usize, 47usize); +payload_add!(17usize, 31usize, 48usize); +payload_add!(17usize, 32usize, 49usize); +payload_add!(17usize, 33usize, 50usize); +payload_add!(17usize, 34usize, 51usize); +payload_add!(17usize, 35usize, 52usize); +payload_add!(17usize, 36usize, 53usize); +payload_add!(17usize, 37usize, 54usize); +payload_add!(17usize, 38usize, 55usize); +payload_add!(17usize, 39usize, 56usize); +payload_add!(17usize, 40usize, 57usize); +payload_add!(17usize, 41usize, 58usize); +payload_add!(17usize, 42usize, 59usize); +payload_add!(17usize, 43usize, 60usize); +payload_add!(17usize, 44usize, 61usize); +payload_add!(17usize, 45usize, 62usize); +payload_add!(17usize, 46usize, 63usize); +payload_add!(17usize, 47usize, 64usize); +payload_add!(17usize, 48usize, 65usize); +payload_add!(18usize, 1usize, 19usize); +payload_add!(18usize, 2usize, 20usize); +payload_add!(18usize, 3usize, 21usize); +payload_add!(18usize, 4usize, 22usize); +payload_add!(18usize, 5usize, 23usize); +payload_add!(18usize, 6usize, 24usize); +payload_add!(18usize, 7usize, 25usize); +payload_add!(18usize, 8usize, 26usize); +payload_add!(18usize, 9usize, 27usize); +payload_add!(18usize, 10usize, 28usize); +payload_add!(18usize, 11usize, 29usize); +payload_add!(18usize, 12usize, 30usize); +payload_add!(18usize, 13usize, 31usize); +payload_add!(18usize, 14usize, 32usize); +payload_add!(18usize, 15usize, 33usize); +payload_add!(18usize, 16usize, 34usize); +payload_add!(18usize, 17usize, 35usize); +payload_add!(18usize, 18usize, 36usize); +payload_add!(18usize, 19usize, 37usize); +payload_add!(18usize, 20usize, 38usize); +payload_add!(18usize, 21usize, 39usize); +payload_add!(18usize, 22usize, 40usize); +payload_add!(18usize, 23usize, 41usize); +payload_add!(18usize, 24usize, 42usize); +payload_add!(18usize, 25usize, 43usize); +payload_add!(18usize, 26usize, 44usize); +payload_add!(18usize, 27usize, 45usize); +payload_add!(18usize, 28usize, 46usize); +payload_add!(18usize, 29usize, 47usize); +payload_add!(18usize, 30usize, 48usize); +payload_add!(18usize, 31usize, 49usize); +payload_add!(18usize, 32usize, 50usize); +payload_add!(18usize, 33usize, 51usize); +payload_add!(18usize, 34usize, 52usize); +payload_add!(18usize, 35usize, 53usize); +payload_add!(18usize, 36usize, 54usize); +payload_add!(18usize, 37usize, 55usize); +payload_add!(18usize, 38usize, 56usize); +payload_add!(18usize, 39usize, 57usize); +payload_add!(18usize, 40usize, 58usize); +payload_add!(18usize, 41usize, 59usize); +payload_add!(18usize, 42usize, 60usize); +payload_add!(18usize, 43usize, 61usize); +payload_add!(18usize, 44usize, 62usize); +payload_add!(18usize, 45usize, 63usize); +payload_add!(18usize, 46usize, 64usize); +payload_add!(18usize, 47usize, 65usize); +payload_add!(18usize, 48usize, 66usize); +payload_add!(19usize, 1usize, 20usize); +payload_add!(19usize, 2usize, 21usize); +payload_add!(19usize, 3usize, 22usize); +payload_add!(19usize, 4usize, 23usize); +payload_add!(19usize, 5usize, 24usize); +payload_add!(19usize, 6usize, 25usize); +payload_add!(19usize, 7usize, 26usize); +payload_add!(19usize, 8usize, 27usize); +payload_add!(19usize, 9usize, 28usize); +payload_add!(19usize, 10usize, 29usize); +payload_add!(19usize, 11usize, 30usize); +payload_add!(19usize, 12usize, 31usize); +payload_add!(19usize, 13usize, 32usize); +payload_add!(19usize, 14usize, 33usize); +payload_add!(19usize, 15usize, 34usize); +payload_add!(19usize, 16usize, 35usize); +payload_add!(19usize, 17usize, 36usize); +payload_add!(19usize, 18usize, 37usize); +payload_add!(19usize, 19usize, 38usize); +payload_add!(19usize, 20usize, 39usize); +payload_add!(19usize, 21usize, 40usize); +payload_add!(19usize, 22usize, 41usize); +payload_add!(19usize, 23usize, 42usize); +payload_add!(19usize, 24usize, 43usize); +payload_add!(19usize, 25usize, 44usize); +payload_add!(19usize, 26usize, 45usize); +payload_add!(19usize, 27usize, 46usize); +payload_add!(19usize, 28usize, 47usize); +payload_add!(19usize, 29usize, 48usize); +payload_add!(19usize, 30usize, 49usize); +payload_add!(19usize, 31usize, 50usize); +payload_add!(19usize, 32usize, 51usize); +payload_add!(19usize, 33usize, 52usize); +payload_add!(19usize, 34usize, 53usize); +payload_add!(19usize, 35usize, 54usize); +payload_add!(19usize, 36usize, 55usize); +payload_add!(19usize, 37usize, 56usize); +payload_add!(19usize, 38usize, 57usize); +payload_add!(19usize, 39usize, 58usize); +payload_add!(19usize, 40usize, 59usize); +payload_add!(19usize, 41usize, 60usize); +payload_add!(19usize, 42usize, 61usize); +payload_add!(19usize, 43usize, 62usize); +payload_add!(19usize, 44usize, 63usize); +payload_add!(19usize, 45usize, 64usize); +payload_add!(19usize, 46usize, 65usize); +payload_add!(19usize, 47usize, 66usize); +payload_add!(19usize, 48usize, 67usize); +payload_add!(20usize, 1usize, 21usize); +payload_add!(20usize, 2usize, 22usize); +payload_add!(20usize, 3usize, 23usize); +payload_add!(20usize, 4usize, 24usize); +payload_add!(20usize, 5usize, 25usize); +payload_add!(20usize, 6usize, 26usize); +payload_add!(20usize, 7usize, 27usize); +payload_add!(20usize, 8usize, 28usize); +payload_add!(20usize, 9usize, 29usize); +payload_add!(20usize, 10usize, 30usize); +payload_add!(20usize, 11usize, 31usize); +payload_add!(20usize, 12usize, 32usize); +payload_add!(20usize, 13usize, 33usize); +payload_add!(20usize, 14usize, 34usize); +payload_add!(20usize, 15usize, 35usize); +payload_add!(20usize, 16usize, 36usize); +payload_add!(20usize, 17usize, 37usize); +payload_add!(20usize, 18usize, 38usize); +payload_add!(20usize, 19usize, 39usize); +payload_add!(20usize, 20usize, 40usize); +payload_add!(20usize, 21usize, 41usize); +payload_add!(20usize, 22usize, 42usize); +payload_add!(20usize, 23usize, 43usize); +payload_add!(20usize, 24usize, 44usize); +payload_add!(20usize, 25usize, 45usize); +payload_add!(20usize, 26usize, 46usize); +payload_add!(20usize, 27usize, 47usize); +payload_add!(20usize, 28usize, 48usize); +payload_add!(20usize, 29usize, 49usize); +payload_add!(20usize, 30usize, 50usize); +payload_add!(20usize, 31usize, 51usize); +payload_add!(20usize, 32usize, 52usize); +payload_add!(20usize, 33usize, 53usize); +payload_add!(20usize, 34usize, 54usize); +payload_add!(20usize, 35usize, 55usize); +payload_add!(20usize, 36usize, 56usize); +payload_add!(20usize, 37usize, 57usize); +payload_add!(20usize, 38usize, 58usize); +payload_add!(20usize, 39usize, 59usize); +payload_add!(20usize, 40usize, 60usize); +payload_add!(20usize, 41usize, 61usize); +payload_add!(20usize, 42usize, 62usize); +payload_add!(20usize, 43usize, 63usize); +payload_add!(20usize, 44usize, 64usize); +payload_add!(20usize, 45usize, 65usize); +payload_add!(20usize, 46usize, 66usize); +payload_add!(20usize, 47usize, 67usize); +payload_add!(20usize, 48usize, 68usize); +payload_add!(21usize, 1usize, 22usize); +payload_add!(21usize, 2usize, 23usize); +payload_add!(21usize, 3usize, 24usize); +payload_add!(21usize, 4usize, 25usize); +payload_add!(21usize, 5usize, 26usize); +payload_add!(21usize, 6usize, 27usize); +payload_add!(21usize, 7usize, 28usize); +payload_add!(21usize, 8usize, 29usize); +payload_add!(21usize, 9usize, 30usize); +payload_add!(21usize, 10usize, 31usize); +payload_add!(21usize, 11usize, 32usize); +payload_add!(21usize, 12usize, 33usize); +payload_add!(21usize, 13usize, 34usize); +payload_add!(21usize, 14usize, 35usize); +payload_add!(21usize, 15usize, 36usize); +payload_add!(21usize, 16usize, 37usize); +payload_add!(21usize, 17usize, 38usize); +payload_add!(21usize, 18usize, 39usize); +payload_add!(21usize, 19usize, 40usize); +payload_add!(21usize, 20usize, 41usize); +payload_add!(21usize, 21usize, 42usize); +payload_add!(21usize, 22usize, 43usize); +payload_add!(21usize, 23usize, 44usize); +payload_add!(21usize, 24usize, 45usize); +payload_add!(21usize, 25usize, 46usize); +payload_add!(21usize, 26usize, 47usize); +payload_add!(21usize, 27usize, 48usize); +payload_add!(21usize, 28usize, 49usize); +payload_add!(21usize, 29usize, 50usize); +payload_add!(21usize, 30usize, 51usize); +payload_add!(21usize, 31usize, 52usize); +payload_add!(21usize, 32usize, 53usize); +payload_add!(21usize, 33usize, 54usize); +payload_add!(21usize, 34usize, 55usize); +payload_add!(21usize, 35usize, 56usize); +payload_add!(21usize, 36usize, 57usize); +payload_add!(21usize, 37usize, 58usize); +payload_add!(21usize, 38usize, 59usize); +payload_add!(21usize, 39usize, 60usize); +payload_add!(21usize, 40usize, 61usize); +payload_add!(21usize, 41usize, 62usize); +payload_add!(21usize, 42usize, 63usize); +payload_add!(21usize, 43usize, 64usize); +payload_add!(21usize, 44usize, 65usize); +payload_add!(21usize, 45usize, 66usize); +payload_add!(21usize, 46usize, 67usize); +payload_add!(21usize, 47usize, 68usize); +payload_add!(21usize, 48usize, 69usize); +payload_add!(22usize, 1usize, 23usize); +payload_add!(22usize, 2usize, 24usize); +payload_add!(22usize, 3usize, 25usize); +payload_add!(22usize, 4usize, 26usize); +payload_add!(22usize, 5usize, 27usize); +payload_add!(22usize, 6usize, 28usize); +payload_add!(22usize, 7usize, 29usize); +payload_add!(22usize, 8usize, 30usize); +payload_add!(22usize, 9usize, 31usize); +payload_add!(22usize, 10usize, 32usize); +payload_add!(22usize, 11usize, 33usize); +payload_add!(22usize, 12usize, 34usize); +payload_add!(22usize, 13usize, 35usize); +payload_add!(22usize, 14usize, 36usize); +payload_add!(22usize, 15usize, 37usize); +payload_add!(22usize, 16usize, 38usize); +payload_add!(22usize, 17usize, 39usize); +payload_add!(22usize, 18usize, 40usize); +payload_add!(22usize, 19usize, 41usize); +payload_add!(22usize, 20usize, 42usize); +payload_add!(22usize, 21usize, 43usize); +payload_add!(22usize, 22usize, 44usize); +payload_add!(22usize, 23usize, 45usize); +payload_add!(22usize, 24usize, 46usize); +payload_add!(22usize, 25usize, 47usize); +payload_add!(22usize, 26usize, 48usize); +payload_add!(22usize, 27usize, 49usize); +payload_add!(22usize, 28usize, 50usize); +payload_add!(22usize, 29usize, 51usize); +payload_add!(22usize, 30usize, 52usize); +payload_add!(22usize, 31usize, 53usize); +payload_add!(22usize, 32usize, 54usize); +payload_add!(22usize, 33usize, 55usize); +payload_add!(22usize, 34usize, 56usize); +payload_add!(22usize, 35usize, 57usize); +payload_add!(22usize, 36usize, 58usize); +payload_add!(22usize, 37usize, 59usize); +payload_add!(22usize, 38usize, 60usize); +payload_add!(22usize, 39usize, 61usize); +payload_add!(22usize, 40usize, 62usize); +payload_add!(22usize, 41usize, 63usize); +payload_add!(22usize, 42usize, 64usize); +payload_add!(22usize, 43usize, 65usize); +payload_add!(22usize, 44usize, 66usize); +payload_add!(22usize, 45usize, 67usize); +payload_add!(22usize, 46usize, 68usize); +payload_add!(22usize, 47usize, 69usize); +payload_add!(22usize, 48usize, 70usize); +payload_add!(23usize, 1usize, 24usize); +payload_add!(23usize, 2usize, 25usize); +payload_add!(23usize, 3usize, 26usize); +payload_add!(23usize, 4usize, 27usize); +payload_add!(23usize, 5usize, 28usize); +payload_add!(23usize, 6usize, 29usize); +payload_add!(23usize, 7usize, 30usize); +payload_add!(23usize, 8usize, 31usize); +payload_add!(23usize, 9usize, 32usize); +payload_add!(23usize, 10usize, 33usize); +payload_add!(23usize, 11usize, 34usize); +payload_add!(23usize, 12usize, 35usize); +payload_add!(23usize, 13usize, 36usize); +payload_add!(23usize, 14usize, 37usize); +payload_add!(23usize, 15usize, 38usize); +payload_add!(23usize, 16usize, 39usize); +payload_add!(23usize, 17usize, 40usize); +payload_add!(23usize, 18usize, 41usize); +payload_add!(23usize, 19usize, 42usize); +payload_add!(23usize, 20usize, 43usize); +payload_add!(23usize, 21usize, 44usize); +payload_add!(23usize, 22usize, 45usize); +payload_add!(23usize, 23usize, 46usize); +payload_add!(23usize, 24usize, 47usize); +payload_add!(23usize, 25usize, 48usize); +payload_add!(23usize, 26usize, 49usize); +payload_add!(23usize, 27usize, 50usize); +payload_add!(23usize, 28usize, 51usize); +payload_add!(23usize, 29usize, 52usize); +payload_add!(23usize, 30usize, 53usize); +payload_add!(23usize, 31usize, 54usize); +payload_add!(23usize, 32usize, 55usize); +payload_add!(23usize, 33usize, 56usize); +payload_add!(23usize, 34usize, 57usize); +payload_add!(23usize, 35usize, 58usize); +payload_add!(23usize, 36usize, 59usize); +payload_add!(23usize, 37usize, 60usize); +payload_add!(23usize, 38usize, 61usize); +payload_add!(23usize, 39usize, 62usize); +payload_add!(23usize, 40usize, 63usize); +payload_add!(23usize, 41usize, 64usize); +payload_add!(23usize, 42usize, 65usize); +payload_add!(23usize, 43usize, 66usize); +payload_add!(23usize, 44usize, 67usize); +payload_add!(23usize, 45usize, 68usize); +payload_add!(23usize, 46usize, 69usize); +payload_add!(23usize, 47usize, 70usize); +payload_add!(23usize, 48usize, 71usize); +payload_add!(24usize, 1usize, 25usize); +payload_add!(24usize, 2usize, 26usize); +payload_add!(24usize, 3usize, 27usize); +payload_add!(24usize, 4usize, 28usize); +payload_add!(24usize, 5usize, 29usize); +payload_add!(24usize, 6usize, 30usize); +payload_add!(24usize, 7usize, 31usize); +payload_add!(24usize, 8usize, 32usize); +payload_add!(24usize, 9usize, 33usize); +payload_add!(24usize, 10usize, 34usize); +payload_add!(24usize, 11usize, 35usize); +payload_add!(24usize, 12usize, 36usize); +payload_add!(24usize, 13usize, 37usize); +payload_add!(24usize, 14usize, 38usize); +payload_add!(24usize, 15usize, 39usize); +payload_add!(24usize, 16usize, 40usize); +payload_add!(24usize, 17usize, 41usize); +payload_add!(24usize, 18usize, 42usize); +payload_add!(24usize, 19usize, 43usize); +payload_add!(24usize, 20usize, 44usize); +payload_add!(24usize, 21usize, 45usize); +payload_add!(24usize, 22usize, 46usize); +payload_add!(24usize, 23usize, 47usize); +payload_add!(24usize, 24usize, 48usize); +payload_add!(24usize, 25usize, 49usize); +payload_add!(24usize, 26usize, 50usize); +payload_add!(24usize, 27usize, 51usize); +payload_add!(24usize, 28usize, 52usize); +payload_add!(24usize, 29usize, 53usize); +payload_add!(24usize, 30usize, 54usize); +payload_add!(24usize, 31usize, 55usize); +payload_add!(24usize, 32usize, 56usize); +payload_add!(24usize, 33usize, 57usize); +payload_add!(24usize, 34usize, 58usize); +payload_add!(24usize, 35usize, 59usize); +payload_add!(24usize, 36usize, 60usize); +payload_add!(24usize, 37usize, 61usize); +payload_add!(24usize, 38usize, 62usize); +payload_add!(24usize, 39usize, 63usize); +payload_add!(24usize, 40usize, 64usize); +payload_add!(24usize, 41usize, 65usize); +payload_add!(24usize, 42usize, 66usize); +payload_add!(24usize, 43usize, 67usize); +payload_add!(24usize, 44usize, 68usize); +payload_add!(24usize, 45usize, 69usize); +payload_add!(24usize, 46usize, 70usize); +payload_add!(24usize, 47usize, 71usize); +payload_add!(24usize, 48usize, 72usize); +payload_add!(25usize, 1usize, 26usize); +payload_add!(25usize, 2usize, 27usize); +payload_add!(25usize, 3usize, 28usize); +payload_add!(25usize, 4usize, 29usize); +payload_add!(25usize, 5usize, 30usize); +payload_add!(25usize, 6usize, 31usize); +payload_add!(25usize, 7usize, 32usize); +payload_add!(25usize, 8usize, 33usize); +payload_add!(25usize, 9usize, 34usize); +payload_add!(25usize, 10usize, 35usize); +payload_add!(25usize, 11usize, 36usize); +payload_add!(25usize, 12usize, 37usize); +payload_add!(25usize, 13usize, 38usize); +payload_add!(25usize, 14usize, 39usize); +payload_add!(25usize, 15usize, 40usize); +payload_add!(25usize, 16usize, 41usize); +payload_add!(25usize, 17usize, 42usize); +payload_add!(25usize, 18usize, 43usize); +payload_add!(25usize, 19usize, 44usize); +payload_add!(25usize, 20usize, 45usize); +payload_add!(25usize, 21usize, 46usize); +payload_add!(25usize, 22usize, 47usize); +payload_add!(25usize, 23usize, 48usize); +payload_add!(25usize, 24usize, 49usize); +payload_add!(25usize, 25usize, 50usize); +payload_add!(25usize, 26usize, 51usize); +payload_add!(25usize, 27usize, 52usize); +payload_add!(25usize, 28usize, 53usize); +payload_add!(25usize, 29usize, 54usize); +payload_add!(25usize, 30usize, 55usize); +payload_add!(25usize, 31usize, 56usize); +payload_add!(25usize, 32usize, 57usize); +payload_add!(25usize, 33usize, 58usize); +payload_add!(25usize, 34usize, 59usize); +payload_add!(25usize, 35usize, 60usize); +payload_add!(25usize, 36usize, 61usize); +payload_add!(25usize, 37usize, 62usize); +payload_add!(25usize, 38usize, 63usize); +payload_add!(25usize, 39usize, 64usize); +payload_add!(25usize, 40usize, 65usize); +payload_add!(25usize, 41usize, 66usize); +payload_add!(25usize, 42usize, 67usize); +payload_add!(25usize, 43usize, 68usize); +payload_add!(25usize, 44usize, 69usize); +payload_add!(25usize, 45usize, 70usize); +payload_add!(25usize, 46usize, 71usize); +payload_add!(25usize, 47usize, 72usize); +payload_add!(25usize, 48usize, 73usize); +payload_add!(26usize, 1usize, 27usize); +payload_add!(26usize, 2usize, 28usize); +payload_add!(26usize, 3usize, 29usize); +payload_add!(26usize, 4usize, 30usize); +payload_add!(26usize, 5usize, 31usize); +payload_add!(26usize, 6usize, 32usize); +payload_add!(26usize, 7usize, 33usize); +payload_add!(26usize, 8usize, 34usize); +payload_add!(26usize, 9usize, 35usize); +payload_add!(26usize, 10usize, 36usize); +payload_add!(26usize, 11usize, 37usize); +payload_add!(26usize, 12usize, 38usize); +payload_add!(26usize, 13usize, 39usize); +payload_add!(26usize, 14usize, 40usize); +payload_add!(26usize, 15usize, 41usize); +payload_add!(26usize, 16usize, 42usize); +payload_add!(26usize, 17usize, 43usize); +payload_add!(26usize, 18usize, 44usize); +payload_add!(26usize, 19usize, 45usize); +payload_add!(26usize, 20usize, 46usize); +payload_add!(26usize, 21usize, 47usize); +payload_add!(26usize, 22usize, 48usize); +payload_add!(26usize, 23usize, 49usize); +payload_add!(26usize, 24usize, 50usize); +payload_add!(26usize, 25usize, 51usize); +payload_add!(26usize, 26usize, 52usize); +payload_add!(26usize, 27usize, 53usize); +payload_add!(26usize, 28usize, 54usize); +payload_add!(26usize, 29usize, 55usize); +payload_add!(26usize, 30usize, 56usize); +payload_add!(26usize, 31usize, 57usize); +payload_add!(26usize, 32usize, 58usize); +payload_add!(26usize, 33usize, 59usize); +payload_add!(26usize, 34usize, 60usize); +payload_add!(26usize, 35usize, 61usize); +payload_add!(26usize, 36usize, 62usize); +payload_add!(26usize, 37usize, 63usize); +payload_add!(26usize, 38usize, 64usize); +payload_add!(26usize, 39usize, 65usize); +payload_add!(26usize, 40usize, 66usize); +payload_add!(26usize, 41usize, 67usize); +payload_add!(26usize, 42usize, 68usize); +payload_add!(26usize, 43usize, 69usize); +payload_add!(26usize, 44usize, 70usize); +payload_add!(26usize, 45usize, 71usize); +payload_add!(26usize, 46usize, 72usize); +payload_add!(26usize, 47usize, 73usize); +payload_add!(26usize, 48usize, 74usize); +payload_add!(27usize, 1usize, 28usize); +payload_add!(27usize, 2usize, 29usize); +payload_add!(27usize, 3usize, 30usize); +payload_add!(27usize, 4usize, 31usize); +payload_add!(27usize, 5usize, 32usize); +payload_add!(27usize, 6usize, 33usize); +payload_add!(27usize, 7usize, 34usize); +payload_add!(27usize, 8usize, 35usize); +payload_add!(27usize, 9usize, 36usize); +payload_add!(27usize, 10usize, 37usize); +payload_add!(27usize, 11usize, 38usize); +payload_add!(27usize, 12usize, 39usize); +payload_add!(27usize, 13usize, 40usize); +payload_add!(27usize, 14usize, 41usize); +payload_add!(27usize, 15usize, 42usize); +payload_add!(27usize, 16usize, 43usize); +payload_add!(27usize, 17usize, 44usize); +payload_add!(27usize, 18usize, 45usize); +payload_add!(27usize, 19usize, 46usize); +payload_add!(27usize, 20usize, 47usize); +payload_add!(27usize, 21usize, 48usize); +payload_add!(27usize, 22usize, 49usize); +payload_add!(27usize, 23usize, 50usize); +payload_add!(27usize, 24usize, 51usize); +payload_add!(27usize, 25usize, 52usize); +payload_add!(27usize, 26usize, 53usize); +payload_add!(27usize, 27usize, 54usize); +payload_add!(27usize, 28usize, 55usize); +payload_add!(27usize, 29usize, 56usize); +payload_add!(27usize, 30usize, 57usize); +payload_add!(27usize, 31usize, 58usize); +payload_add!(27usize, 32usize, 59usize); +payload_add!(27usize, 33usize, 60usize); +payload_add!(27usize, 34usize, 61usize); +payload_add!(27usize, 35usize, 62usize); +payload_add!(27usize, 36usize, 63usize); +payload_add!(27usize, 37usize, 64usize); +payload_add!(27usize, 38usize, 65usize); +payload_add!(27usize, 39usize, 66usize); +payload_add!(27usize, 40usize, 67usize); +payload_add!(27usize, 41usize, 68usize); +payload_add!(27usize, 42usize, 69usize); +payload_add!(27usize, 43usize, 70usize); +payload_add!(27usize, 44usize, 71usize); +payload_add!(27usize, 45usize, 72usize); +payload_add!(27usize, 46usize, 73usize); +payload_add!(27usize, 47usize, 74usize); +payload_add!(27usize, 48usize, 75usize); +payload_add!(28usize, 1usize, 29usize); +payload_add!(28usize, 2usize, 30usize); +payload_add!(28usize, 3usize, 31usize); +payload_add!(28usize, 4usize, 32usize); +payload_add!(28usize, 5usize, 33usize); +payload_add!(28usize, 6usize, 34usize); +payload_add!(28usize, 7usize, 35usize); +payload_add!(28usize, 8usize, 36usize); +payload_add!(28usize, 9usize, 37usize); +payload_add!(28usize, 10usize, 38usize); +payload_add!(28usize, 11usize, 39usize); +payload_add!(28usize, 12usize, 40usize); +payload_add!(28usize, 13usize, 41usize); +payload_add!(28usize, 14usize, 42usize); +payload_add!(28usize, 15usize, 43usize); +payload_add!(28usize, 16usize, 44usize); +payload_add!(28usize, 17usize, 45usize); +payload_add!(28usize, 18usize, 46usize); +payload_add!(28usize, 19usize, 47usize); +payload_add!(28usize, 20usize, 48usize); +payload_add!(28usize, 21usize, 49usize); +payload_add!(28usize, 22usize, 50usize); +payload_add!(28usize, 23usize, 51usize); +payload_add!(28usize, 24usize, 52usize); +payload_add!(28usize, 25usize, 53usize); +payload_add!(28usize, 26usize, 54usize); +payload_add!(28usize, 27usize, 55usize); +payload_add!(28usize, 28usize, 56usize); +payload_add!(28usize, 29usize, 57usize); +payload_add!(28usize, 30usize, 58usize); +payload_add!(28usize, 31usize, 59usize); +payload_add!(28usize, 32usize, 60usize); +payload_add!(28usize, 33usize, 61usize); +payload_add!(28usize, 34usize, 62usize); +payload_add!(28usize, 35usize, 63usize); +payload_add!(28usize, 36usize, 64usize); +payload_add!(28usize, 37usize, 65usize); +payload_add!(28usize, 38usize, 66usize); +payload_add!(28usize, 39usize, 67usize); +payload_add!(28usize, 40usize, 68usize); +payload_add!(28usize, 41usize, 69usize); +payload_add!(28usize, 42usize, 70usize); +payload_add!(28usize, 43usize, 71usize); +payload_add!(28usize, 44usize, 72usize); +payload_add!(28usize, 45usize, 73usize); +payload_add!(28usize, 46usize, 74usize); +payload_add!(28usize, 47usize, 75usize); +payload_add!(28usize, 48usize, 76usize); +payload_add!(29usize, 1usize, 30usize); +payload_add!(29usize, 2usize, 31usize); +payload_add!(29usize, 3usize, 32usize); +payload_add!(29usize, 4usize, 33usize); +payload_add!(29usize, 5usize, 34usize); +payload_add!(29usize, 6usize, 35usize); +payload_add!(29usize, 7usize, 36usize); +payload_add!(29usize, 8usize, 37usize); +payload_add!(29usize, 9usize, 38usize); +payload_add!(29usize, 10usize, 39usize); +payload_add!(29usize, 11usize, 40usize); +payload_add!(29usize, 12usize, 41usize); +payload_add!(29usize, 13usize, 42usize); +payload_add!(29usize, 14usize, 43usize); +payload_add!(29usize, 15usize, 44usize); +payload_add!(29usize, 16usize, 45usize); +payload_add!(29usize, 17usize, 46usize); +payload_add!(29usize, 18usize, 47usize); +payload_add!(29usize, 19usize, 48usize); +payload_add!(29usize, 20usize, 49usize); +payload_add!(29usize, 21usize, 50usize); +payload_add!(29usize, 22usize, 51usize); +payload_add!(29usize, 23usize, 52usize); +payload_add!(29usize, 24usize, 53usize); +payload_add!(29usize, 25usize, 54usize); +payload_add!(29usize, 26usize, 55usize); +payload_add!(29usize, 27usize, 56usize); +payload_add!(29usize, 28usize, 57usize); +payload_add!(29usize, 29usize, 58usize); +payload_add!(29usize, 30usize, 59usize); +payload_add!(29usize, 31usize, 60usize); +payload_add!(29usize, 32usize, 61usize); +payload_add!(29usize, 33usize, 62usize); +payload_add!(29usize, 34usize, 63usize); +payload_add!(29usize, 35usize, 64usize); +payload_add!(29usize, 36usize, 65usize); +payload_add!(29usize, 37usize, 66usize); +payload_add!(29usize, 38usize, 67usize); +payload_add!(29usize, 39usize, 68usize); +payload_add!(29usize, 40usize, 69usize); +payload_add!(29usize, 41usize, 70usize); +payload_add!(29usize, 42usize, 71usize); +payload_add!(29usize, 43usize, 72usize); +payload_add!(29usize, 44usize, 73usize); +payload_add!(29usize, 45usize, 74usize); +payload_add!(29usize, 46usize, 75usize); +payload_add!(29usize, 47usize, 76usize); +payload_add!(29usize, 48usize, 77usize); +payload_add!(30usize, 1usize, 31usize); +payload_add!(30usize, 2usize, 32usize); +payload_add!(30usize, 3usize, 33usize); +payload_add!(30usize, 4usize, 34usize); +payload_add!(30usize, 5usize, 35usize); +payload_add!(30usize, 6usize, 36usize); +payload_add!(30usize, 7usize, 37usize); +payload_add!(30usize, 8usize, 38usize); +payload_add!(30usize, 9usize, 39usize); +payload_add!(30usize, 10usize, 40usize); +payload_add!(30usize, 11usize, 41usize); +payload_add!(30usize, 12usize, 42usize); +payload_add!(30usize, 13usize, 43usize); +payload_add!(30usize, 14usize, 44usize); +payload_add!(30usize, 15usize, 45usize); +payload_add!(30usize, 16usize, 46usize); +payload_add!(30usize, 17usize, 47usize); +payload_add!(30usize, 18usize, 48usize); +payload_add!(30usize, 19usize, 49usize); +payload_add!(30usize, 20usize, 50usize); +payload_add!(30usize, 21usize, 51usize); +payload_add!(30usize, 22usize, 52usize); +payload_add!(30usize, 23usize, 53usize); +payload_add!(30usize, 24usize, 54usize); +payload_add!(30usize, 25usize, 55usize); +payload_add!(30usize, 26usize, 56usize); +payload_add!(30usize, 27usize, 57usize); +payload_add!(30usize, 28usize, 58usize); +payload_add!(30usize, 29usize, 59usize); +payload_add!(30usize, 30usize, 60usize); +payload_add!(30usize, 31usize, 61usize); +payload_add!(30usize, 32usize, 62usize); +payload_add!(30usize, 33usize, 63usize); +payload_add!(30usize, 34usize, 64usize); +payload_add!(30usize, 35usize, 65usize); +payload_add!(30usize, 36usize, 66usize); +payload_add!(30usize, 37usize, 67usize); +payload_add!(30usize, 38usize, 68usize); +payload_add!(30usize, 39usize, 69usize); +payload_add!(30usize, 40usize, 70usize); +payload_add!(30usize, 41usize, 71usize); +payload_add!(30usize, 42usize, 72usize); +payload_add!(30usize, 43usize, 73usize); +payload_add!(30usize, 44usize, 74usize); +payload_add!(30usize, 45usize, 75usize); +payload_add!(30usize, 46usize, 76usize); +payload_add!(30usize, 47usize, 77usize); +payload_add!(30usize, 48usize, 78usize); +payload_add!(31usize, 1usize, 32usize); +payload_add!(31usize, 2usize, 33usize); +payload_add!(31usize, 3usize, 34usize); +payload_add!(31usize, 4usize, 35usize); +payload_add!(31usize, 5usize, 36usize); +payload_add!(31usize, 6usize, 37usize); +payload_add!(31usize, 7usize, 38usize); +payload_add!(31usize, 8usize, 39usize); +payload_add!(31usize, 9usize, 40usize); +payload_add!(31usize, 10usize, 41usize); +payload_add!(31usize, 11usize, 42usize); +payload_add!(31usize, 12usize, 43usize); +payload_add!(31usize, 13usize, 44usize); +payload_add!(31usize, 14usize, 45usize); +payload_add!(31usize, 15usize, 46usize); +payload_add!(31usize, 16usize, 47usize); +payload_add!(31usize, 17usize, 48usize); +payload_add!(31usize, 18usize, 49usize); +payload_add!(31usize, 19usize, 50usize); +payload_add!(31usize, 20usize, 51usize); +payload_add!(31usize, 21usize, 52usize); +payload_add!(31usize, 22usize, 53usize); +payload_add!(31usize, 23usize, 54usize); +payload_add!(31usize, 24usize, 55usize); +payload_add!(31usize, 25usize, 56usize); +payload_add!(31usize, 26usize, 57usize); +payload_add!(31usize, 27usize, 58usize); +payload_add!(31usize, 28usize, 59usize); +payload_add!(31usize, 29usize, 60usize); +payload_add!(31usize, 30usize, 61usize); +payload_add!(31usize, 31usize, 62usize); +payload_add!(31usize, 32usize, 63usize); +payload_add!(31usize, 33usize, 64usize); +payload_add!(31usize, 34usize, 65usize); +payload_add!(31usize, 35usize, 66usize); +payload_add!(31usize, 36usize, 67usize); +payload_add!(31usize, 37usize, 68usize); +payload_add!(31usize, 38usize, 69usize); +payload_add!(31usize, 39usize, 70usize); +payload_add!(31usize, 40usize, 71usize); +payload_add!(31usize, 41usize, 72usize); +payload_add!(31usize, 42usize, 73usize); +payload_add!(31usize, 43usize, 74usize); +payload_add!(31usize, 44usize, 75usize); +payload_add!(31usize, 45usize, 76usize); +payload_add!(31usize, 46usize, 77usize); +payload_add!(31usize, 47usize, 78usize); +payload_add!(31usize, 48usize, 79usize); +payload_add!(32usize, 1usize, 33usize); +payload_add!(32usize, 2usize, 34usize); +payload_add!(32usize, 3usize, 35usize); +payload_add!(32usize, 4usize, 36usize); +payload_add!(32usize, 5usize, 37usize); +payload_add!(32usize, 6usize, 38usize); +payload_add!(32usize, 7usize, 39usize); +payload_add!(32usize, 8usize, 40usize); +payload_add!(32usize, 9usize, 41usize); +payload_add!(32usize, 10usize, 42usize); +payload_add!(32usize, 11usize, 43usize); +payload_add!(32usize, 12usize, 44usize); +payload_add!(32usize, 13usize, 45usize); +payload_add!(32usize, 14usize, 46usize); +payload_add!(32usize, 15usize, 47usize); +payload_add!(32usize, 16usize, 48usize); +payload_add!(32usize, 17usize, 49usize); +payload_add!(32usize, 18usize, 50usize); +payload_add!(32usize, 19usize, 51usize); +payload_add!(32usize, 20usize, 52usize); +payload_add!(32usize, 21usize, 53usize); +payload_add!(32usize, 22usize, 54usize); +payload_add!(32usize, 23usize, 55usize); +payload_add!(32usize, 24usize, 56usize); +payload_add!(32usize, 25usize, 57usize); +payload_add!(32usize, 26usize, 58usize); +payload_add!(32usize, 27usize, 59usize); +payload_add!(32usize, 28usize, 60usize); +payload_add!(32usize, 29usize, 61usize); +payload_add!(32usize, 30usize, 62usize); +payload_add!(32usize, 31usize, 63usize); +payload_add!(32usize, 32usize, 64usize); +payload_add!(32usize, 33usize, 65usize); +payload_add!(32usize, 34usize, 66usize); +payload_add!(32usize, 35usize, 67usize); +payload_add!(32usize, 36usize, 68usize); +payload_add!(32usize, 37usize, 69usize); +payload_add!(32usize, 38usize, 70usize); +payload_add!(32usize, 39usize, 71usize); +payload_add!(32usize, 40usize, 72usize); +payload_add!(32usize, 41usize, 73usize); +payload_add!(32usize, 42usize, 74usize); +payload_add!(32usize, 43usize, 75usize); +payload_add!(32usize, 44usize, 76usize); +payload_add!(32usize, 45usize, 77usize); +payload_add!(32usize, 46usize, 78usize); +payload_add!(32usize, 47usize, 79usize); +payload_add!(32usize, 48usize, 80usize); +payload_add!(33usize, 1usize, 34usize); +payload_add!(33usize, 2usize, 35usize); +payload_add!(33usize, 3usize, 36usize); +payload_add!(33usize, 4usize, 37usize); +payload_add!(33usize, 5usize, 38usize); +payload_add!(33usize, 6usize, 39usize); +payload_add!(33usize, 7usize, 40usize); +payload_add!(33usize, 8usize, 41usize); +payload_add!(33usize, 9usize, 42usize); +payload_add!(33usize, 10usize, 43usize); +payload_add!(33usize, 11usize, 44usize); +payload_add!(33usize, 12usize, 45usize); +payload_add!(33usize, 13usize, 46usize); +payload_add!(33usize, 14usize, 47usize); +payload_add!(33usize, 15usize, 48usize); +payload_add!(33usize, 16usize, 49usize); +payload_add!(33usize, 17usize, 50usize); +payload_add!(33usize, 18usize, 51usize); +payload_add!(33usize, 19usize, 52usize); +payload_add!(33usize, 20usize, 53usize); +payload_add!(33usize, 21usize, 54usize); +payload_add!(33usize, 22usize, 55usize); +payload_add!(33usize, 23usize, 56usize); +payload_add!(33usize, 24usize, 57usize); +payload_add!(33usize, 25usize, 58usize); +payload_add!(33usize, 26usize, 59usize); +payload_add!(33usize, 27usize, 60usize); +payload_add!(33usize, 28usize, 61usize); +payload_add!(33usize, 29usize, 62usize); +payload_add!(33usize, 30usize, 63usize); +payload_add!(33usize, 31usize, 64usize); +payload_add!(33usize, 32usize, 65usize); +payload_add!(33usize, 33usize, 66usize); +payload_add!(33usize, 34usize, 67usize); +payload_add!(33usize, 35usize, 68usize); +payload_add!(33usize, 36usize, 69usize); +payload_add!(33usize, 37usize, 70usize); +payload_add!(33usize, 38usize, 71usize); +payload_add!(33usize, 39usize, 72usize); +payload_add!(33usize, 40usize, 73usize); +payload_add!(33usize, 41usize, 74usize); +payload_add!(33usize, 42usize, 75usize); +payload_add!(33usize, 43usize, 76usize); +payload_add!(33usize, 44usize, 77usize); +payload_add!(33usize, 45usize, 78usize); +payload_add!(33usize, 46usize, 79usize); +payload_add!(33usize, 47usize, 80usize); +payload_add!(33usize, 48usize, 81usize); +payload_add!(34usize, 1usize, 35usize); +payload_add!(34usize, 2usize, 36usize); +payload_add!(34usize, 3usize, 37usize); +payload_add!(34usize, 4usize, 38usize); +payload_add!(34usize, 5usize, 39usize); +payload_add!(34usize, 6usize, 40usize); +payload_add!(34usize, 7usize, 41usize); +payload_add!(34usize, 8usize, 42usize); +payload_add!(34usize, 9usize, 43usize); +payload_add!(34usize, 10usize, 44usize); +payload_add!(34usize, 11usize, 45usize); +payload_add!(34usize, 12usize, 46usize); +payload_add!(34usize, 13usize, 47usize); +payload_add!(34usize, 14usize, 48usize); +payload_add!(34usize, 15usize, 49usize); +payload_add!(34usize, 16usize, 50usize); +payload_add!(34usize, 17usize, 51usize); +payload_add!(34usize, 18usize, 52usize); +payload_add!(34usize, 19usize, 53usize); +payload_add!(34usize, 20usize, 54usize); +payload_add!(34usize, 21usize, 55usize); +payload_add!(34usize, 22usize, 56usize); +payload_add!(34usize, 23usize, 57usize); +payload_add!(34usize, 24usize, 58usize); +payload_add!(34usize, 25usize, 59usize); +payload_add!(34usize, 26usize, 60usize); +payload_add!(34usize, 27usize, 61usize); +payload_add!(34usize, 28usize, 62usize); +payload_add!(34usize, 29usize, 63usize); +payload_add!(34usize, 30usize, 64usize); +payload_add!(34usize, 31usize, 65usize); +payload_add!(34usize, 32usize, 66usize); +payload_add!(34usize, 33usize, 67usize); +payload_add!(34usize, 34usize, 68usize); +payload_add!(34usize, 35usize, 69usize); +payload_add!(34usize, 36usize, 70usize); +payload_add!(34usize, 37usize, 71usize); +payload_add!(34usize, 38usize, 72usize); +payload_add!(34usize, 39usize, 73usize); +payload_add!(34usize, 40usize, 74usize); +payload_add!(34usize, 41usize, 75usize); +payload_add!(34usize, 42usize, 76usize); +payload_add!(34usize, 43usize, 77usize); +payload_add!(34usize, 44usize, 78usize); +payload_add!(34usize, 45usize, 79usize); +payload_add!(34usize, 46usize, 80usize); +payload_add!(34usize, 47usize, 81usize); +payload_add!(34usize, 48usize, 82usize); +payload_add!(35usize, 1usize, 36usize); +payload_add!(35usize, 2usize, 37usize); +payload_add!(35usize, 3usize, 38usize); +payload_add!(35usize, 4usize, 39usize); +payload_add!(35usize, 5usize, 40usize); +payload_add!(35usize, 6usize, 41usize); +payload_add!(35usize, 7usize, 42usize); +payload_add!(35usize, 8usize, 43usize); +payload_add!(35usize, 9usize, 44usize); +payload_add!(35usize, 10usize, 45usize); +payload_add!(35usize, 11usize, 46usize); +payload_add!(35usize, 12usize, 47usize); +payload_add!(35usize, 13usize, 48usize); +payload_add!(35usize, 14usize, 49usize); +payload_add!(35usize, 15usize, 50usize); +payload_add!(35usize, 16usize, 51usize); +payload_add!(35usize, 17usize, 52usize); +payload_add!(35usize, 18usize, 53usize); +payload_add!(35usize, 19usize, 54usize); +payload_add!(35usize, 20usize, 55usize); +payload_add!(35usize, 21usize, 56usize); +payload_add!(35usize, 22usize, 57usize); +payload_add!(35usize, 23usize, 58usize); +payload_add!(35usize, 24usize, 59usize); +payload_add!(35usize, 25usize, 60usize); +payload_add!(35usize, 26usize, 61usize); +payload_add!(35usize, 27usize, 62usize); +payload_add!(35usize, 28usize, 63usize); +payload_add!(35usize, 29usize, 64usize); +payload_add!(35usize, 30usize, 65usize); +payload_add!(35usize, 31usize, 66usize); +payload_add!(35usize, 32usize, 67usize); +payload_add!(35usize, 33usize, 68usize); +payload_add!(35usize, 34usize, 69usize); +payload_add!(35usize, 35usize, 70usize); +payload_add!(35usize, 36usize, 71usize); +payload_add!(35usize, 37usize, 72usize); +payload_add!(35usize, 38usize, 73usize); +payload_add!(35usize, 39usize, 74usize); +payload_add!(35usize, 40usize, 75usize); +payload_add!(35usize, 41usize, 76usize); +payload_add!(35usize, 42usize, 77usize); +payload_add!(35usize, 43usize, 78usize); +payload_add!(35usize, 44usize, 79usize); +payload_add!(35usize, 45usize, 80usize); +payload_add!(35usize, 46usize, 81usize); +payload_add!(35usize, 47usize, 82usize); +payload_add!(35usize, 48usize, 83usize); +payload_add!(36usize, 1usize, 37usize); +payload_add!(36usize, 2usize, 38usize); +payload_add!(36usize, 3usize, 39usize); +payload_add!(36usize, 4usize, 40usize); +payload_add!(36usize, 5usize, 41usize); +payload_add!(36usize, 6usize, 42usize); +payload_add!(36usize, 7usize, 43usize); +payload_add!(36usize, 8usize, 44usize); +payload_add!(36usize, 9usize, 45usize); +payload_add!(36usize, 10usize, 46usize); +payload_add!(36usize, 11usize, 47usize); +payload_add!(36usize, 12usize, 48usize); +payload_add!(36usize, 13usize, 49usize); +payload_add!(36usize, 14usize, 50usize); +payload_add!(36usize, 15usize, 51usize); +payload_add!(36usize, 16usize, 52usize); +payload_add!(36usize, 17usize, 53usize); +payload_add!(36usize, 18usize, 54usize); +payload_add!(36usize, 19usize, 55usize); +payload_add!(36usize, 20usize, 56usize); +payload_add!(36usize, 21usize, 57usize); +payload_add!(36usize, 22usize, 58usize); +payload_add!(36usize, 23usize, 59usize); +payload_add!(36usize, 24usize, 60usize); +payload_add!(36usize, 25usize, 61usize); +payload_add!(36usize, 26usize, 62usize); +payload_add!(36usize, 27usize, 63usize); +payload_add!(36usize, 28usize, 64usize); +payload_add!(36usize, 29usize, 65usize); +payload_add!(36usize, 30usize, 66usize); +payload_add!(36usize, 31usize, 67usize); +payload_add!(36usize, 32usize, 68usize); +payload_add!(36usize, 33usize, 69usize); +payload_add!(36usize, 34usize, 70usize); +payload_add!(36usize, 35usize, 71usize); +payload_add!(36usize, 36usize, 72usize); +payload_add!(36usize, 37usize, 73usize); +payload_add!(36usize, 38usize, 74usize); +payload_add!(36usize, 39usize, 75usize); +payload_add!(36usize, 40usize, 76usize); +payload_add!(36usize, 41usize, 77usize); +payload_add!(36usize, 42usize, 78usize); +payload_add!(36usize, 43usize, 79usize); +payload_add!(36usize, 44usize, 80usize); +payload_add!(36usize, 45usize, 81usize); +payload_add!(36usize, 46usize, 82usize); +payload_add!(36usize, 47usize, 83usize); +payload_add!(36usize, 48usize, 84usize); +payload_add!(37usize, 1usize, 38usize); +payload_add!(37usize, 2usize, 39usize); +payload_add!(37usize, 3usize, 40usize); +payload_add!(37usize, 4usize, 41usize); +payload_add!(37usize, 5usize, 42usize); +payload_add!(37usize, 6usize, 43usize); +payload_add!(37usize, 7usize, 44usize); +payload_add!(37usize, 8usize, 45usize); +payload_add!(37usize, 9usize, 46usize); +payload_add!(37usize, 10usize, 47usize); +payload_add!(37usize, 11usize, 48usize); +payload_add!(37usize, 12usize, 49usize); +payload_add!(37usize, 13usize, 50usize); +payload_add!(37usize, 14usize, 51usize); +payload_add!(37usize, 15usize, 52usize); +payload_add!(37usize, 16usize, 53usize); +payload_add!(37usize, 17usize, 54usize); +payload_add!(37usize, 18usize, 55usize); +payload_add!(37usize, 19usize, 56usize); +payload_add!(37usize, 20usize, 57usize); +payload_add!(37usize, 21usize, 58usize); +payload_add!(37usize, 22usize, 59usize); +payload_add!(37usize, 23usize, 60usize); +payload_add!(37usize, 24usize, 61usize); +payload_add!(37usize, 25usize, 62usize); +payload_add!(37usize, 26usize, 63usize); +payload_add!(37usize, 27usize, 64usize); +payload_add!(37usize, 28usize, 65usize); +payload_add!(37usize, 29usize, 66usize); +payload_add!(37usize, 30usize, 67usize); +payload_add!(37usize, 31usize, 68usize); +payload_add!(37usize, 32usize, 69usize); +payload_add!(37usize, 33usize, 70usize); +payload_add!(37usize, 34usize, 71usize); +payload_add!(37usize, 35usize, 72usize); +payload_add!(37usize, 36usize, 73usize); +payload_add!(37usize, 37usize, 74usize); +payload_add!(37usize, 38usize, 75usize); +payload_add!(37usize, 39usize, 76usize); +payload_add!(37usize, 40usize, 77usize); +payload_add!(37usize, 41usize, 78usize); +payload_add!(37usize, 42usize, 79usize); +payload_add!(37usize, 43usize, 80usize); +payload_add!(37usize, 44usize, 81usize); +payload_add!(37usize, 45usize, 82usize); +payload_add!(37usize, 46usize, 83usize); +payload_add!(37usize, 47usize, 84usize); +payload_add!(37usize, 48usize, 85usize); +payload_add!(38usize, 1usize, 39usize); +payload_add!(38usize, 2usize, 40usize); +payload_add!(38usize, 3usize, 41usize); +payload_add!(38usize, 4usize, 42usize); +payload_add!(38usize, 5usize, 43usize); +payload_add!(38usize, 6usize, 44usize); +payload_add!(38usize, 7usize, 45usize); +payload_add!(38usize, 8usize, 46usize); +payload_add!(38usize, 9usize, 47usize); +payload_add!(38usize, 10usize, 48usize); +payload_add!(38usize, 11usize, 49usize); +payload_add!(38usize, 12usize, 50usize); +payload_add!(38usize, 13usize, 51usize); +payload_add!(38usize, 14usize, 52usize); +payload_add!(38usize, 15usize, 53usize); +payload_add!(38usize, 16usize, 54usize); +payload_add!(38usize, 17usize, 55usize); +payload_add!(38usize, 18usize, 56usize); +payload_add!(38usize, 19usize, 57usize); +payload_add!(38usize, 20usize, 58usize); +payload_add!(38usize, 21usize, 59usize); +payload_add!(38usize, 22usize, 60usize); +payload_add!(38usize, 23usize, 61usize); +payload_add!(38usize, 24usize, 62usize); +payload_add!(38usize, 25usize, 63usize); +payload_add!(38usize, 26usize, 64usize); +payload_add!(38usize, 27usize, 65usize); +payload_add!(38usize, 28usize, 66usize); +payload_add!(38usize, 29usize, 67usize); +payload_add!(38usize, 30usize, 68usize); +payload_add!(38usize, 31usize, 69usize); +payload_add!(38usize, 32usize, 70usize); +payload_add!(38usize, 33usize, 71usize); +payload_add!(38usize, 34usize, 72usize); +payload_add!(38usize, 35usize, 73usize); +payload_add!(38usize, 36usize, 74usize); +payload_add!(38usize, 37usize, 75usize); +payload_add!(38usize, 38usize, 76usize); +payload_add!(38usize, 39usize, 77usize); +payload_add!(38usize, 40usize, 78usize); +payload_add!(38usize, 41usize, 79usize); +payload_add!(38usize, 42usize, 80usize); +payload_add!(38usize, 43usize, 81usize); +payload_add!(38usize, 44usize, 82usize); +payload_add!(38usize, 45usize, 83usize); +payload_add!(38usize, 46usize, 84usize); +payload_add!(38usize, 47usize, 85usize); +payload_add!(38usize, 48usize, 86usize); +payload_add!(39usize, 1usize, 40usize); +payload_add!(39usize, 2usize, 41usize); +payload_add!(39usize, 3usize, 42usize); +payload_add!(39usize, 4usize, 43usize); +payload_add!(39usize, 5usize, 44usize); +payload_add!(39usize, 6usize, 45usize); +payload_add!(39usize, 7usize, 46usize); +payload_add!(39usize, 8usize, 47usize); +payload_add!(39usize, 9usize, 48usize); +payload_add!(39usize, 10usize, 49usize); +payload_add!(39usize, 11usize, 50usize); +payload_add!(39usize, 12usize, 51usize); +payload_add!(39usize, 13usize, 52usize); +payload_add!(39usize, 14usize, 53usize); +payload_add!(39usize, 15usize, 54usize); +payload_add!(39usize, 16usize, 55usize); +payload_add!(39usize, 17usize, 56usize); +payload_add!(39usize, 18usize, 57usize); +payload_add!(39usize, 19usize, 58usize); +payload_add!(39usize, 20usize, 59usize); +payload_add!(39usize, 21usize, 60usize); +payload_add!(39usize, 22usize, 61usize); +payload_add!(39usize, 23usize, 62usize); +payload_add!(39usize, 24usize, 63usize); +payload_add!(39usize, 25usize, 64usize); +payload_add!(39usize, 26usize, 65usize); +payload_add!(39usize, 27usize, 66usize); +payload_add!(39usize, 28usize, 67usize); +payload_add!(39usize, 29usize, 68usize); +payload_add!(39usize, 30usize, 69usize); +payload_add!(39usize, 31usize, 70usize); +payload_add!(39usize, 32usize, 71usize); +payload_add!(39usize, 33usize, 72usize); +payload_add!(39usize, 34usize, 73usize); +payload_add!(39usize, 35usize, 74usize); +payload_add!(39usize, 36usize, 75usize); +payload_add!(39usize, 37usize, 76usize); +payload_add!(39usize, 38usize, 77usize); +payload_add!(39usize, 39usize, 78usize); +payload_add!(39usize, 40usize, 79usize); +payload_add!(39usize, 41usize, 80usize); +payload_add!(39usize, 42usize, 81usize); +payload_add!(39usize, 43usize, 82usize); +payload_add!(39usize, 44usize, 83usize); +payload_add!(39usize, 45usize, 84usize); +payload_add!(39usize, 46usize, 85usize); +payload_add!(39usize, 47usize, 86usize); +payload_add!(39usize, 48usize, 87usize); +payload_add!(40usize, 1usize, 41usize); +payload_add!(40usize, 2usize, 42usize); +payload_add!(40usize, 3usize, 43usize); +payload_add!(40usize, 4usize, 44usize); +payload_add!(40usize, 5usize, 45usize); +payload_add!(40usize, 6usize, 46usize); +payload_add!(40usize, 7usize, 47usize); +payload_add!(40usize, 8usize, 48usize); +payload_add!(40usize, 9usize, 49usize); +payload_add!(40usize, 10usize, 50usize); +payload_add!(40usize, 11usize, 51usize); +payload_add!(40usize, 12usize, 52usize); +payload_add!(40usize, 13usize, 53usize); +payload_add!(40usize, 14usize, 54usize); +payload_add!(40usize, 15usize, 55usize); +payload_add!(40usize, 16usize, 56usize); +payload_add!(40usize, 17usize, 57usize); +payload_add!(40usize, 18usize, 58usize); +payload_add!(40usize, 19usize, 59usize); +payload_add!(40usize, 20usize, 60usize); +payload_add!(40usize, 21usize, 61usize); +payload_add!(40usize, 22usize, 62usize); +payload_add!(40usize, 23usize, 63usize); +payload_add!(40usize, 24usize, 64usize); +payload_add!(40usize, 25usize, 65usize); +payload_add!(40usize, 26usize, 66usize); +payload_add!(40usize, 27usize, 67usize); +payload_add!(40usize, 28usize, 68usize); +payload_add!(40usize, 29usize, 69usize); +payload_add!(40usize, 30usize, 70usize); +payload_add!(40usize, 31usize, 71usize); +payload_add!(40usize, 32usize, 72usize); +payload_add!(40usize, 33usize, 73usize); +payload_add!(40usize, 34usize, 74usize); +payload_add!(40usize, 35usize, 75usize); +payload_add!(40usize, 36usize, 76usize); +payload_add!(40usize, 37usize, 77usize); +payload_add!(40usize, 38usize, 78usize); +payload_add!(40usize, 39usize, 79usize); +payload_add!(40usize, 40usize, 80usize); +payload_add!(40usize, 41usize, 81usize); +payload_add!(40usize, 42usize, 82usize); +payload_add!(40usize, 43usize, 83usize); +payload_add!(40usize, 44usize, 84usize); +payload_add!(40usize, 45usize, 85usize); +payload_add!(40usize, 46usize, 86usize); +payload_add!(40usize, 47usize, 87usize); +payload_add!(40usize, 48usize, 88usize); +payload_add!(41usize, 1usize, 42usize); +payload_add!(41usize, 2usize, 43usize); +payload_add!(41usize, 3usize, 44usize); +payload_add!(41usize, 4usize, 45usize); +payload_add!(41usize, 5usize, 46usize); +payload_add!(41usize, 6usize, 47usize); +payload_add!(41usize, 7usize, 48usize); +payload_add!(41usize, 8usize, 49usize); +payload_add!(41usize, 9usize, 50usize); +payload_add!(41usize, 10usize, 51usize); +payload_add!(41usize, 11usize, 52usize); +payload_add!(41usize, 12usize, 53usize); +payload_add!(41usize, 13usize, 54usize); +payload_add!(41usize, 14usize, 55usize); +payload_add!(41usize, 15usize, 56usize); +payload_add!(41usize, 16usize, 57usize); +payload_add!(41usize, 17usize, 58usize); +payload_add!(41usize, 18usize, 59usize); +payload_add!(41usize, 19usize, 60usize); +payload_add!(41usize, 20usize, 61usize); +payload_add!(41usize, 21usize, 62usize); +payload_add!(41usize, 22usize, 63usize); +payload_add!(41usize, 23usize, 64usize); +payload_add!(41usize, 24usize, 65usize); +payload_add!(41usize, 25usize, 66usize); +payload_add!(41usize, 26usize, 67usize); +payload_add!(41usize, 27usize, 68usize); +payload_add!(41usize, 28usize, 69usize); +payload_add!(41usize, 29usize, 70usize); +payload_add!(41usize, 30usize, 71usize); +payload_add!(41usize, 31usize, 72usize); +payload_add!(41usize, 32usize, 73usize); +payload_add!(41usize, 33usize, 74usize); +payload_add!(41usize, 34usize, 75usize); +payload_add!(41usize, 35usize, 76usize); +payload_add!(41usize, 36usize, 77usize); +payload_add!(41usize, 37usize, 78usize); +payload_add!(41usize, 38usize, 79usize); +payload_add!(41usize, 39usize, 80usize); +payload_add!(41usize, 40usize, 81usize); +payload_add!(41usize, 41usize, 82usize); +payload_add!(41usize, 42usize, 83usize); +payload_add!(41usize, 43usize, 84usize); +payload_add!(41usize, 44usize, 85usize); +payload_add!(41usize, 45usize, 86usize); +payload_add!(41usize, 46usize, 87usize); +payload_add!(41usize, 47usize, 88usize); +payload_add!(41usize, 48usize, 89usize); +payload_add!(42usize, 1usize, 43usize); +payload_add!(42usize, 2usize, 44usize); +payload_add!(42usize, 3usize, 45usize); +payload_add!(42usize, 4usize, 46usize); +payload_add!(42usize, 5usize, 47usize); +payload_add!(42usize, 6usize, 48usize); +payload_add!(42usize, 7usize, 49usize); +payload_add!(42usize, 8usize, 50usize); +payload_add!(42usize, 9usize, 51usize); +payload_add!(42usize, 10usize, 52usize); +payload_add!(42usize, 11usize, 53usize); +payload_add!(42usize, 12usize, 54usize); +payload_add!(42usize, 13usize, 55usize); +payload_add!(42usize, 14usize, 56usize); +payload_add!(42usize, 15usize, 57usize); +payload_add!(42usize, 16usize, 58usize); +payload_add!(42usize, 17usize, 59usize); +payload_add!(42usize, 18usize, 60usize); +payload_add!(42usize, 19usize, 61usize); +payload_add!(42usize, 20usize, 62usize); +payload_add!(42usize, 21usize, 63usize); +payload_add!(42usize, 22usize, 64usize); +payload_add!(42usize, 23usize, 65usize); +payload_add!(42usize, 24usize, 66usize); +payload_add!(42usize, 25usize, 67usize); +payload_add!(42usize, 26usize, 68usize); +payload_add!(42usize, 27usize, 69usize); +payload_add!(42usize, 28usize, 70usize); +payload_add!(42usize, 29usize, 71usize); +payload_add!(42usize, 30usize, 72usize); +payload_add!(42usize, 31usize, 73usize); +payload_add!(42usize, 32usize, 74usize); +payload_add!(42usize, 33usize, 75usize); +payload_add!(42usize, 34usize, 76usize); +payload_add!(42usize, 35usize, 77usize); +payload_add!(42usize, 36usize, 78usize); +payload_add!(42usize, 37usize, 79usize); +payload_add!(42usize, 38usize, 80usize); +payload_add!(42usize, 39usize, 81usize); +payload_add!(42usize, 40usize, 82usize); +payload_add!(42usize, 41usize, 83usize); +payload_add!(42usize, 42usize, 84usize); +payload_add!(42usize, 43usize, 85usize); +payload_add!(42usize, 44usize, 86usize); +payload_add!(42usize, 45usize, 87usize); +payload_add!(42usize, 46usize, 88usize); +payload_add!(42usize, 47usize, 89usize); +payload_add!(42usize, 48usize, 90usize); +payload_add!(43usize, 1usize, 44usize); +payload_add!(43usize, 2usize, 45usize); +payload_add!(43usize, 3usize, 46usize); +payload_add!(43usize, 4usize, 47usize); +payload_add!(43usize, 5usize, 48usize); +payload_add!(43usize, 6usize, 49usize); +payload_add!(43usize, 7usize, 50usize); +payload_add!(43usize, 8usize, 51usize); +payload_add!(43usize, 9usize, 52usize); +payload_add!(43usize, 10usize, 53usize); +payload_add!(43usize, 11usize, 54usize); +payload_add!(43usize, 12usize, 55usize); +payload_add!(43usize, 13usize, 56usize); +payload_add!(43usize, 14usize, 57usize); +payload_add!(43usize, 15usize, 58usize); +payload_add!(43usize, 16usize, 59usize); +payload_add!(43usize, 17usize, 60usize); +payload_add!(43usize, 18usize, 61usize); +payload_add!(43usize, 19usize, 62usize); +payload_add!(43usize, 20usize, 63usize); +payload_add!(43usize, 21usize, 64usize); +payload_add!(43usize, 22usize, 65usize); +payload_add!(43usize, 23usize, 66usize); +payload_add!(43usize, 24usize, 67usize); +payload_add!(43usize, 25usize, 68usize); +payload_add!(43usize, 26usize, 69usize); +payload_add!(43usize, 27usize, 70usize); +payload_add!(43usize, 28usize, 71usize); +payload_add!(43usize, 29usize, 72usize); +payload_add!(43usize, 30usize, 73usize); +payload_add!(43usize, 31usize, 74usize); +payload_add!(43usize, 32usize, 75usize); +payload_add!(43usize, 33usize, 76usize); +payload_add!(43usize, 34usize, 77usize); +payload_add!(43usize, 35usize, 78usize); +payload_add!(43usize, 36usize, 79usize); +payload_add!(43usize, 37usize, 80usize); +payload_add!(43usize, 38usize, 81usize); +payload_add!(43usize, 39usize, 82usize); +payload_add!(43usize, 40usize, 83usize); +payload_add!(43usize, 41usize, 84usize); +payload_add!(43usize, 42usize, 85usize); +payload_add!(43usize, 43usize, 86usize); +payload_add!(43usize, 44usize, 87usize); +payload_add!(43usize, 45usize, 88usize); +payload_add!(43usize, 46usize, 89usize); +payload_add!(43usize, 47usize, 90usize); +payload_add!(43usize, 48usize, 91usize); +payload_add!(44usize, 1usize, 45usize); +payload_add!(44usize, 2usize, 46usize); +payload_add!(44usize, 3usize, 47usize); +payload_add!(44usize, 4usize, 48usize); +payload_add!(44usize, 5usize, 49usize); +payload_add!(44usize, 6usize, 50usize); +payload_add!(44usize, 7usize, 51usize); +payload_add!(44usize, 8usize, 52usize); +payload_add!(44usize, 9usize, 53usize); +payload_add!(44usize, 10usize, 54usize); +payload_add!(44usize, 11usize, 55usize); +payload_add!(44usize, 12usize, 56usize); +payload_add!(44usize, 13usize, 57usize); +payload_add!(44usize, 14usize, 58usize); +payload_add!(44usize, 15usize, 59usize); +payload_add!(44usize, 16usize, 60usize); +payload_add!(44usize, 17usize, 61usize); +payload_add!(44usize, 18usize, 62usize); +payload_add!(44usize, 19usize, 63usize); +payload_add!(44usize, 20usize, 64usize); +payload_add!(44usize, 21usize, 65usize); +payload_add!(44usize, 22usize, 66usize); +payload_add!(44usize, 23usize, 67usize); +payload_add!(44usize, 24usize, 68usize); +payload_add!(44usize, 25usize, 69usize); +payload_add!(44usize, 26usize, 70usize); +payload_add!(44usize, 27usize, 71usize); +payload_add!(44usize, 28usize, 72usize); +payload_add!(44usize, 29usize, 73usize); +payload_add!(44usize, 30usize, 74usize); +payload_add!(44usize, 31usize, 75usize); +payload_add!(44usize, 32usize, 76usize); +payload_add!(44usize, 33usize, 77usize); +payload_add!(44usize, 34usize, 78usize); +payload_add!(44usize, 35usize, 79usize); +payload_add!(44usize, 36usize, 80usize); +payload_add!(44usize, 37usize, 81usize); +payload_add!(44usize, 38usize, 82usize); +payload_add!(44usize, 39usize, 83usize); +payload_add!(44usize, 40usize, 84usize); +payload_add!(44usize, 41usize, 85usize); +payload_add!(44usize, 42usize, 86usize); +payload_add!(44usize, 43usize, 87usize); +payload_add!(44usize, 44usize, 88usize); +payload_add!(44usize, 45usize, 89usize); +payload_add!(44usize, 46usize, 90usize); +payload_add!(44usize, 47usize, 91usize); +payload_add!(44usize, 48usize, 92usize); +payload_add!(45usize, 1usize, 46usize); +payload_add!(45usize, 2usize, 47usize); +payload_add!(45usize, 3usize, 48usize); +payload_add!(45usize, 4usize, 49usize); +payload_add!(45usize, 5usize, 50usize); +payload_add!(45usize, 6usize, 51usize); +payload_add!(45usize, 7usize, 52usize); +payload_add!(45usize, 8usize, 53usize); +payload_add!(45usize, 9usize, 54usize); +payload_add!(45usize, 10usize, 55usize); +payload_add!(45usize, 11usize, 56usize); +payload_add!(45usize, 12usize, 57usize); +payload_add!(45usize, 13usize, 58usize); +payload_add!(45usize, 14usize, 59usize); +payload_add!(45usize, 15usize, 60usize); +payload_add!(45usize, 16usize, 61usize); +payload_add!(45usize, 17usize, 62usize); +payload_add!(45usize, 18usize, 63usize); +payload_add!(45usize, 19usize, 64usize); +payload_add!(45usize, 20usize, 65usize); +payload_add!(45usize, 21usize, 66usize); +payload_add!(45usize, 22usize, 67usize); +payload_add!(45usize, 23usize, 68usize); +payload_add!(45usize, 24usize, 69usize); +payload_add!(45usize, 25usize, 70usize); +payload_add!(45usize, 26usize, 71usize); +payload_add!(45usize, 27usize, 72usize); +payload_add!(45usize, 28usize, 73usize); +payload_add!(45usize, 29usize, 74usize); +payload_add!(45usize, 30usize, 75usize); +payload_add!(45usize, 31usize, 76usize); +payload_add!(45usize, 32usize, 77usize); +payload_add!(45usize, 33usize, 78usize); +payload_add!(45usize, 34usize, 79usize); +payload_add!(45usize, 35usize, 80usize); +payload_add!(45usize, 36usize, 81usize); +payload_add!(45usize, 37usize, 82usize); +payload_add!(45usize, 38usize, 83usize); +payload_add!(45usize, 39usize, 84usize); +payload_add!(45usize, 40usize, 85usize); +payload_add!(45usize, 41usize, 86usize); +payload_add!(45usize, 42usize, 87usize); +payload_add!(45usize, 43usize, 88usize); +payload_add!(45usize, 44usize, 89usize); +payload_add!(45usize, 45usize, 90usize); +payload_add!(45usize, 46usize, 91usize); +payload_add!(45usize, 47usize, 92usize); +payload_add!(45usize, 48usize, 93usize); +payload_add!(46usize, 1usize, 47usize); +payload_add!(46usize, 2usize, 48usize); +payload_add!(46usize, 3usize, 49usize); +payload_add!(46usize, 4usize, 50usize); +payload_add!(46usize, 5usize, 51usize); +payload_add!(46usize, 6usize, 52usize); +payload_add!(46usize, 7usize, 53usize); +payload_add!(46usize, 8usize, 54usize); +payload_add!(46usize, 9usize, 55usize); +payload_add!(46usize, 10usize, 56usize); +payload_add!(46usize, 11usize, 57usize); +payload_add!(46usize, 12usize, 58usize); +payload_add!(46usize, 13usize, 59usize); +payload_add!(46usize, 14usize, 60usize); +payload_add!(46usize, 15usize, 61usize); +payload_add!(46usize, 16usize, 62usize); +payload_add!(46usize, 17usize, 63usize); +payload_add!(46usize, 18usize, 64usize); +payload_add!(46usize, 19usize, 65usize); +payload_add!(46usize, 20usize, 66usize); +payload_add!(46usize, 21usize, 67usize); +payload_add!(46usize, 22usize, 68usize); +payload_add!(46usize, 23usize, 69usize); +payload_add!(46usize, 24usize, 70usize); +payload_add!(46usize, 25usize, 71usize); +payload_add!(46usize, 26usize, 72usize); +payload_add!(46usize, 27usize, 73usize); +payload_add!(46usize, 28usize, 74usize); +payload_add!(46usize, 29usize, 75usize); +payload_add!(46usize, 30usize, 76usize); +payload_add!(46usize, 31usize, 77usize); +payload_add!(46usize, 32usize, 78usize); +payload_add!(46usize, 33usize, 79usize); +payload_add!(46usize, 34usize, 80usize); +payload_add!(46usize, 35usize, 81usize); +payload_add!(46usize, 36usize, 82usize); +payload_add!(46usize, 37usize, 83usize); +payload_add!(46usize, 38usize, 84usize); +payload_add!(46usize, 39usize, 85usize); +payload_add!(46usize, 40usize, 86usize); +payload_add!(46usize, 41usize, 87usize); +payload_add!(46usize, 42usize, 88usize); +payload_add!(46usize, 43usize, 89usize); +payload_add!(46usize, 44usize, 90usize); +payload_add!(46usize, 45usize, 91usize); +payload_add!(46usize, 46usize, 92usize); +payload_add!(46usize, 47usize, 93usize); +payload_add!(46usize, 48usize, 94usize); +payload_add!(47usize, 1usize, 48usize); +payload_add!(47usize, 2usize, 49usize); +payload_add!(47usize, 3usize, 50usize); +payload_add!(47usize, 4usize, 51usize); +payload_add!(47usize, 5usize, 52usize); +payload_add!(47usize, 6usize, 53usize); +payload_add!(47usize, 7usize, 54usize); +payload_add!(47usize, 8usize, 55usize); +payload_add!(47usize, 9usize, 56usize); +payload_add!(47usize, 10usize, 57usize); +payload_add!(47usize, 11usize, 58usize); +payload_add!(47usize, 12usize, 59usize); +payload_add!(47usize, 13usize, 60usize); +payload_add!(47usize, 14usize, 61usize); +payload_add!(47usize, 15usize, 62usize); +payload_add!(47usize, 16usize, 63usize); +payload_add!(47usize, 17usize, 64usize); +payload_add!(47usize, 18usize, 65usize); +payload_add!(47usize, 19usize, 66usize); +payload_add!(47usize, 20usize, 67usize); +payload_add!(47usize, 21usize, 68usize); +payload_add!(47usize, 22usize, 69usize); +payload_add!(47usize, 23usize, 70usize); +payload_add!(47usize, 24usize, 71usize); +payload_add!(47usize, 25usize, 72usize); +payload_add!(47usize, 26usize, 73usize); +payload_add!(47usize, 27usize, 74usize); +payload_add!(47usize, 28usize, 75usize); +payload_add!(47usize, 29usize, 76usize); +payload_add!(47usize, 30usize, 77usize); +payload_add!(47usize, 31usize, 78usize); +payload_add!(47usize, 32usize, 79usize); +payload_add!(47usize, 33usize, 80usize); +payload_add!(47usize, 34usize, 81usize); +payload_add!(47usize, 35usize, 82usize); +payload_add!(47usize, 36usize, 83usize); +payload_add!(47usize, 37usize, 84usize); +payload_add!(47usize, 38usize, 85usize); +payload_add!(47usize, 39usize, 86usize); +payload_add!(47usize, 40usize, 87usize); +payload_add!(47usize, 41usize, 88usize); +payload_add!(47usize, 42usize, 89usize); +payload_add!(47usize, 43usize, 90usize); +payload_add!(47usize, 44usize, 91usize); +payload_add!(47usize, 45usize, 92usize); +payload_add!(47usize, 46usize, 93usize); +payload_add!(47usize, 47usize, 94usize); +payload_add!(47usize, 48usize, 95usize); +payload_add!(48usize, 1usize, 49usize); +payload_add!(48usize, 2usize, 50usize); +payload_add!(48usize, 3usize, 51usize); +payload_add!(48usize, 4usize, 52usize); +payload_add!(48usize, 5usize, 53usize); +payload_add!(48usize, 6usize, 54usize); +payload_add!(48usize, 7usize, 55usize); +payload_add!(48usize, 8usize, 56usize); +payload_add!(48usize, 9usize, 57usize); +payload_add!(48usize, 10usize, 58usize); +payload_add!(48usize, 11usize, 59usize); +payload_add!(48usize, 12usize, 60usize); +payload_add!(48usize, 13usize, 61usize); +payload_add!(48usize, 14usize, 62usize); +payload_add!(48usize, 15usize, 63usize); +payload_add!(48usize, 16usize, 64usize); +payload_add!(48usize, 17usize, 65usize); +payload_add!(48usize, 18usize, 66usize); +payload_add!(48usize, 19usize, 67usize); +payload_add!(48usize, 20usize, 68usize); +payload_add!(48usize, 21usize, 69usize); +payload_add!(48usize, 22usize, 70usize); +payload_add!(48usize, 23usize, 71usize); +payload_add!(48usize, 24usize, 72usize); +payload_add!(48usize, 25usize, 73usize); +payload_add!(48usize, 26usize, 74usize); +payload_add!(48usize, 27usize, 75usize); +payload_add!(48usize, 28usize, 76usize); +payload_add!(48usize, 29usize, 77usize); +payload_add!(48usize, 30usize, 78usize); +payload_add!(48usize, 31usize, 79usize); +payload_add!(48usize, 32usize, 80usize); +payload_add!(48usize, 33usize, 81usize); +payload_add!(48usize, 34usize, 82usize); +payload_add!(48usize, 35usize, 83usize); +payload_add!(48usize, 36usize, 84usize); +payload_add!(48usize, 37usize, 85usize); +payload_add!(48usize, 38usize, 86usize); +payload_add!(48usize, 39usize, 87usize); +payload_add!(48usize, 40usize, 88usize); +payload_add!(48usize, 41usize, 89usize); +payload_add!(48usize, 42usize, 90usize); +payload_add!(48usize, 43usize, 91usize); +payload_add!(48usize, 44usize, 92usize); +payload_add!(48usize, 45usize, 93usize); +payload_add!(48usize, 46usize, 94usize); +payload_add!(48usize, 47usize, 95usize); +payload_add!(48usize, 48usize, 96usize); diff --git a/framework/base/src/types/managed/wrapped/managed_vec_owned_iter.rs b/framework/base/src/types/managed/wrapped/managed_vec_owned_iter.rs index a40c8c798f..20942e70d4 100644 --- a/framework/base/src/types/managed/wrapped/managed_vec_owned_iter.rs +++ b/framework/base/src/types/managed/wrapped/managed_vec_owned_iter.rs @@ -48,7 +48,7 @@ where fn next(&mut self) -> Option { // managedrev / reference type - let next_byte_start = self.byte_start + T::PAYLOAD_SIZE; + let next_byte_start = self.byte_start + T::payload_size(); if next_byte_start > self.byte_end { return None; } @@ -64,7 +64,8 @@ where } fn size_hint(&self) -> (usize, Option) { - let remaining = (self.byte_end - self.byte_start) / T::PAYLOAD_SIZE; + let size = T::payload_size(); + let remaining = (self.byte_end - self.byte_start) / size; (remaining, Some(remaining)) } } @@ -82,10 +83,10 @@ where T: ManagedVecItem, { fn next_back(&mut self) -> Option { - if self.byte_start + T::PAYLOAD_SIZE > self.byte_end { + if self.byte_start + T::payload_size() > self.byte_end { return None; } - self.byte_end -= T::PAYLOAD_SIZE; + self.byte_end -= T::payload_size(); let result = T::from_byte_reader(|dest_slice| { let _ = self diff --git a/framework/base/src/types/managed/wrapped/managed_vec_ref_iter.rs b/framework/base/src/types/managed/wrapped/managed_vec_ref_iter.rs index 13d837510f..ad04b5eaf4 100644 --- a/framework/base/src/types/managed/wrapped/managed_vec_ref_iter.rs +++ b/framework/base/src/types/managed/wrapped/managed_vec_ref_iter.rs @@ -34,7 +34,7 @@ where type Item = T::Ref<'a>; fn next(&mut self) -> Option { - let next_byte_start = self.byte_start + T::PAYLOAD_SIZE; + let next_byte_start = self.byte_start + T::payload_size(); if next_byte_start > self.byte_end { return None; } @@ -52,7 +52,7 @@ where } fn size_hint(&self) -> (usize, Option) { - let remaining = (self.byte_end - self.byte_start) / T::PAYLOAD_SIZE; + let remaining = (self.byte_end - self.byte_start) / T::payload_size(); (remaining, Some(remaining)) } } @@ -70,10 +70,10 @@ where T: ManagedVecItem, { fn next_back(&mut self) -> Option { - if self.byte_start + T::PAYLOAD_SIZE > self.byte_end { + if self.byte_start + T::payload_size() > self.byte_end { return None; } - self.byte_end -= T::PAYLOAD_SIZE; + self.byte_end -= T::payload_size(); let result = unsafe { T::from_byte_reader_as_borrow(|dest_slice| { diff --git a/framework/base/src/types/managed/wrapped/mod.rs b/framework/base/src/types/managed/wrapped/mod.rs index c5d8d03391..aef9ed6e87 100644 --- a/framework/base/src/types/managed/wrapped/mod.rs +++ b/framework/base/src/types/managed/wrapped/mod.rs @@ -11,6 +11,8 @@ mod managed_option; mod managed_ref; mod managed_vec; mod managed_vec_item; +mod managed_vec_item_nested_tuple; +mod managed_vec_item_payload; mod managed_vec_owned_iter; mod managed_vec_ref; mod managed_vec_ref_iter; @@ -33,6 +35,8 @@ pub use managed_option::ManagedOption; pub use managed_ref::ManagedRef; pub use managed_vec::ManagedVec; pub use managed_vec_item::ManagedVecItem; +pub use managed_vec_item_nested_tuple::ManagedVecItemNestedTuple; +pub use managed_vec_item_payload::*; pub use managed_vec_owned_iter::ManagedVecOwnedIterator; pub use managed_vec_ref::ManagedVecRef; pub use managed_vec_ref_iter::ManagedVecRefIterator; diff --git a/framework/derive/src/managed_vec_item_derive.rs b/framework/derive/src/managed_vec_item_derive.rs index a65f62a37c..1755182f34 100644 --- a/framework/derive/src/managed_vec_item_derive.rs +++ b/framework/derive/src/managed_vec_item_derive.rs @@ -9,19 +9,16 @@ pub fn managed_vec_item_derive(ast: &syn::DeriveInput) -> TokenStream { } } -fn type_payload_size(type_name: &syn::Type) -> proc_macro2::TokenStream { - quote! { - <#type_name as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE - } -} - -fn generate_payload_snippets(fields: &syn::Fields) -> Vec { +fn generate_payload_nested_tuple(fields: &syn::Fields) -> proc_macro2::TokenStream { match fields { - syn::Fields::Named(fields_named) => fields_named - .named - .iter() - .map(|field| type_payload_size(&field.ty)) - .collect(), + syn::Fields::Named(fields_named) => { + let types: Vec<_> = fields_named.named.iter().map(|field| &field.ty).collect(); + let mut result = quote! { () }; + for ty in types.iter().rev() { + result = quote! { (#ty, #result) }; + } + result + }, _ => { panic!("ManagedVecItem only supports named fields") }, @@ -56,8 +53,8 @@ fn generate_from_byte_reader_snippets(fields: &syn::Fields) -> Vec::PAYLOAD_SIZE; - bytes.copy_from_slice(&arr[index .. next_index]); + let next_index = index + <#type_name as multiversx_sc::types::ManagedVecItem>::payload_size(); + bytes.copy_from_slice(&payload_slice[index .. next_index]); index = next_index; }), } @@ -79,8 +76,8 @@ fn generate_to_byte_writer_snippets(fields: &syn::Fields) -> Vec::PAYLOAD_SIZE; - arr[index .. next_index].copy_from_slice(bytes); + let next_index = index + <#type_name as multiversx_sc::types::ManagedVecItem>::payload_size(); + payload_slice[index .. next_index].copy_from_slice(bytes); index = next_index; }); } @@ -92,16 +89,10 @@ fn generate_to_byte_writer_snippets(fields: &syn::Fields) -> Vec proc_macro2::TokenStream { - let name = &ast.ident; - let self_expr = if ast.generics.params.is_empty() { - quote! { #name } - } else { - quote! { #name } - }; +fn generate_payload_buffer_snippet() -> proc_macro2::TokenStream { quote! { - const SELF_PAYLOAD_SIZE: usize = <#self_expr as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE; - let mut arr: [u8; SELF_PAYLOAD_SIZE] = [0u8; SELF_PAYLOAD_SIZE]; + let mut payload = ::new_buffer(); + let payload_slice = multiversx_sc::types::ManagedVecItemPayload::payload_slice_mut(&mut payload); } } @@ -130,7 +121,7 @@ fn enum_derive(data_enum: &syn::DataEnum, ast: &syn::DeriveInput) -> TokenStream let gen = quote! { impl #impl_generics multiversx_sc::types::ManagedVecItem for #name #ty_generics #where_clause { - const PAYLOAD_SIZE: usize = 1; + type PAYLOAD = multiversx_sc::types::ManagedVecItemPayloadBuffer<1>; const SKIPS_RESERIALIZATION: bool = true; type Ref<'a> = Self; @@ -161,23 +152,23 @@ fn enum_derive(data_enum: &syn::DataEnum, ast: &syn::DeriveInput) -> TokenStream fn struct_derive(data_struct: &syn::DataStruct, ast: &syn::DeriveInput) -> TokenStream { let name = &ast.ident; let (impl_generics, ty_generics, where_clause) = &ast.generics.split_for_impl(); - let payload_snippets = generate_payload_snippets(&data_struct.fields); + let payload_nested_tuple = generate_payload_nested_tuple(&data_struct.fields); let skips_reserialization_snippets = generate_skips_reserialization_snippets(&data_struct.fields); let from_byte_reader_snippets = generate_from_byte_reader_snippets(&data_struct.fields); let to_byte_writer_snippets = generate_to_byte_writer_snippets(&data_struct.fields); - let array_init_snippet = generate_array_init_snippet(ast); + let payload_buffer_snippet = generate_payload_buffer_snippet(); let gen = quote! { impl #impl_generics multiversx_sc::types::ManagedVecItem for #name #ty_generics #where_clause { - const PAYLOAD_SIZE: usize = #(#payload_snippets)+*; + type PAYLOAD = <#payload_nested_tuple as multiversx_sc::types::ManagedVecItemNestedTuple>::PAYLOAD; const SKIPS_RESERIALIZATION: bool = #(#skips_reserialization_snippets)&&*; type Ref<'a> = Self; fn from_byte_reader(mut reader: Reader) -> Self { - #array_init_snippet - reader(&mut arr[..]); + #payload_buffer_snippet + reader(payload_slice); let mut index = 0; #name { @@ -190,12 +181,12 @@ fn struct_derive(data_struct: &syn::DataStruct, ast: &syn::DeriveInput) -> Token } fn to_byte_writer R>(&self, mut writer: Writer) -> R { - #array_init_snippet + #payload_buffer_snippet let mut index = 0; #(#to_byte_writer_snippets)* - writer(&arr[..]) + writer(&payload_slice[..]) } } }; diff --git a/framework/scenario/src/api/impl_vh/debug_handle_vh.rs b/framework/scenario/src/api/impl_vh/debug_handle_vh.rs index 6174bc06b7..0623270758 100644 --- a/framework/scenario/src/api/impl_vh/debug_handle_vh.rs +++ b/framework/scenario/src/api/impl_vh/debug_handle_vh.rs @@ -77,7 +77,7 @@ impl From for DebugHandle { } impl ManagedVecItem for DebugHandle { - const PAYLOAD_SIZE: usize = ::PAYLOAD_SIZE; + type PAYLOAD = ::PAYLOAD; const SKIPS_RESERIALIZATION: bool = ::SKIPS_RESERIALIZATION; diff --git a/framework/scenario/tests/derive_managed_vec_item_biguint_test.rs b/framework/scenario/tests/derive_managed_vec_item_biguint_test.rs index 66bafe5278..9e0cfa8c74 100644 --- a/framework/scenario/tests/derive_managed_vec_item_biguint_test.rs +++ b/framework/scenario/tests/derive_managed_vec_item_biguint_test.rs @@ -3,7 +3,7 @@ use multiversx_sc::{ codec, codec::derive::{NestedDecode, NestedEncode, TopDecode, TopEncode}, derive::ManagedVecItem, - types::{BigUint, ManagedType}, + types::{BigUint, ManagedType, ManagedVecItemPayload}, }; use multiversx_sc_scenario::api::StaticApi; @@ -22,7 +22,8 @@ pub struct ManagedStructWithBigUint { #[allow(clippy::assertions_on_constants)] fn struct_with_numbers_static() { assert_eq!( - as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE, + as multiversx_sc::types::ManagedVecItem>::payload_size( + ), 8 ); assert!( @@ -37,8 +38,9 @@ fn managed_struct_to_bytes_writer() { big_uint: BigUint::from(fortytwo), num: 0x12345, }; - let mut arr: [u8; 8] = [0u8; - as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE]; + + let mut payload = as multiversx_sc::types::ManagedVecItem>::PAYLOAD::new_buffer(); + let payload_slice = payload.payload_slice_mut(); let handle_bytes = s.big_uint.get_handle().to_be_bytes(); let expected = [0xff, 0xff, 0xff, handle_bytes[3], 0x00, 0x01, 0x23, 0x45]; @@ -46,9 +48,9 @@ fn managed_struct_to_bytes_writer() { as multiversx_sc::types::ManagedVecItem>::to_byte_writer( &s, |bytes| { - arr[0.. as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE].copy_from_slice(bytes); + payload_slice.copy_from_slice(bytes); - assert_eq!(arr, expected); + assert_eq!(payload_slice, expected); }, ); } @@ -68,7 +70,7 @@ fn managed_struct_from_bytes_reader() { bytes.copy_from_slice( &arr [0 - .. as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE], + .. as multiversx_sc::types::ManagedVecItem>::payload_size()], ); }, ); diff --git a/framework/scenario/tests/derive_managed_vec_item_esdt_token_payment_test.rs b/framework/scenario/tests/derive_managed_vec_item_esdt_token_payment_test.rs index 1e0889c27c..fc7d95343e 100644 --- a/framework/scenario/tests/derive_managed_vec_item_esdt_token_payment_test.rs +++ b/framework/scenario/tests/derive_managed_vec_item_esdt_token_payment_test.rs @@ -3,7 +3,10 @@ use multiversx_sc::{ codec, codec::derive::{NestedDecode, NestedEncode, TopDecode, TopEncode}, derive::ManagedVecItem, - types::{BigUint, EsdtTokenPayment, ManagedByteArray, ManagedType, TokenIdentifier}, + types::{ + BigUint, EsdtTokenPayment, ManagedByteArray, ManagedType, ManagedVecItemPayload, + TokenIdentifier, + }, }; use multiversx_sc_scenario::api::StaticApi; @@ -26,7 +29,7 @@ pub struct ManagedStructWithToken { #[allow(clippy::assertions_on_constants)] fn struct_with_numbers_static() { assert_eq!( - as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE, + as multiversx_sc::types::ManagedVecItem>::payload_size(), 28 ); assert!( @@ -46,8 +49,9 @@ fn struct_to_bytes_writer() { eth_address_1: ManagedByteArray::new_from_bytes(&[1u8; 20]), eth_address_2: ManagedByteArray::new_from_bytes(&[2u8; 20]), }; - let mut arr: [u8; 28] = [0u8; - as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE]; + + let mut payload = as multiversx_sc::types::ManagedVecItem>::PAYLOAD::new_buffer(); + let payload_slice = payload.payload_slice_mut(); let handle1 = s.token.token_identifier.get_handle().to_be_bytes(); let handle2 = s.token.amount.get_handle().to_be_bytes(); @@ -62,11 +66,9 @@ fn struct_to_bytes_writer() { as multiversx_sc::types::ManagedVecItem>::to_byte_writer( &s, |bytes| { - arr[0 - .. as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE] - .copy_from_slice(bytes); + payload_slice.copy_from_slice(bytes); - assert_eq!(arr, expected); + assert_eq!(payload_slice, expected); }, ); } @@ -96,7 +98,7 @@ fn struct_from_bytes_reader() { bytes.copy_from_slice( &arr [0 - .. as multiversx_sc::types::ManagedVecItem>::PAYLOAD_SIZE], + .. as multiversx_sc::types::ManagedVecItem>::payload_size()], ); }, ); diff --git a/framework/scenario/tests/derive_managed_vec_item_simple_enum.rs b/framework/scenario/tests/derive_managed_vec_item_simple_enum.rs index 23e7caca77..1c139f5b84 100644 --- a/framework/scenario/tests/derive_managed_vec_item_simple_enum.rs +++ b/framework/scenario/tests/derive_managed_vec_item_simple_enum.rs @@ -19,7 +19,7 @@ enum SimpleEnum { #[allow(clippy::assertions_on_constants)] fn enum_static() { assert_eq!( - ::PAYLOAD_SIZE, + ::payload_size(), 1 ); assert!(::SKIPS_RESERIALIZATION); diff --git a/framework/scenario/tests/derive_managed_vec_item_struct_1_test.rs b/framework/scenario/tests/derive_managed_vec_item_struct_1_test.rs index 1673008017..e5ee344e3c 100644 --- a/framework/scenario/tests/derive_managed_vec_item_struct_1_test.rs +++ b/framework/scenario/tests/derive_managed_vec_item_struct_1_test.rs @@ -1,4 +1,7 @@ -use multiversx_sc::codec::test_util::{check_dep_encode_decode, check_top_encode_decode}; +use multiversx_sc::{ + codec::test_util::{check_dep_encode_decode, check_top_encode_decode}, + types::ManagedVecItemPayload, +}; multiversx_sc::derive_imports!(); @@ -20,7 +23,7 @@ pub struct Struct1 { #[allow(clippy::assertions_on_constants)] fn struct_1_static() { assert_eq!( - ::PAYLOAD_SIZE, + ::payload_size(), 16 ); assert!(::SKIPS_RESERIALIZATION); @@ -60,13 +63,14 @@ fn struct_1_to_bytes_writer() { u_64: 4u64, bool_field: true, }; - let mut arr: [u8; 16] = [0u8; ::PAYLOAD_SIZE]; + + let mut payload = ::PAYLOAD::new_buffer(); + let payload_slice = payload.payload_slice_mut(); ::to_byte_writer(&s, |bytes| { - arr[0..::PAYLOAD_SIZE] - .copy_from_slice(bytes); + payload_slice.copy_from_slice(bytes); assert_eq!( - arr, + payload_slice, [ 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, @@ -92,7 +96,7 @@ fn struct_1_from_bytes_reader() { let struct_from_bytes = ::from_byte_reader(|bytes| { bytes.copy_from_slice( - &arr[0..::PAYLOAD_SIZE], + &arr[0..::payload_size()], ); }); assert_eq!(s, struct_from_bytes); diff --git a/framework/scenario/tests/derive_managed_vec_item_struct_2_test.rs b/framework/scenario/tests/derive_managed_vec_item_struct_2_test.rs index 90db2ddddc..87fee5ed62 100644 --- a/framework/scenario/tests/derive_managed_vec_item_struct_2_test.rs +++ b/framework/scenario/tests/derive_managed_vec_item_struct_2_test.rs @@ -13,14 +13,14 @@ pub struct Struct2 { pub u_64: u64, pub bool_field: bool, pub opt_field: Option, - pub arr: [u16; 2], + pub arr: u32, } #[test] #[allow(clippy::assertions_on_constants)] fn struct_2_static() { assert_eq!( - ::PAYLOAD_SIZE, + ::payload_size(), 22 ); assert!(!::SKIPS_RESERIALIZATION); @@ -35,7 +35,7 @@ fn struct_to_bytes_writer() { u_64: 4u64, bool_field: true, opt_field: Some(5), - arr: [0x6111, 0x6222], + arr: 0x61116222, }; #[rustfmt::skip] @@ -63,7 +63,7 @@ fn struct_2_from_bytes_reader() { u_64: 4u64, bool_field: false, opt_field: Some(5), - arr: [0x6111, 0x6222], + arr: 0x61116222, }; #[rustfmt::skip] diff --git a/vm/src/tx_mock/tx_managed_types/handle_map.rs b/vm/src/tx_mock/tx_managed_types/handle_map.rs index 62f9c04659..4473e9104b 100644 --- a/vm/src/tx_mock/tx_managed_types/handle_map.rs +++ b/vm/src/tx_mock/tx_managed_types/handle_map.rs @@ -34,14 +34,14 @@ impl HandleMap { // TODO: consider simulating the actual error from the VM self.map .get(&handle) - .unwrap_or_else(|| panic!("handle not found")) + .unwrap_or_else(|| panic!("handle not found: {handle}")) } pub fn get_mut(&mut self, handle: RawHandle) -> &mut V { // TODO: consider simulating the actual error from the VM self.map .get_mut(&handle) - .unwrap_or_else(|| panic!("handle not found")) + .unwrap_or_else(|| panic!("handle not found: {handle}")) } pub fn insert(&mut self, handle: RawHandle, value: V) {